Skip to main content

LinqAI / LinqProtocol

LinqAI / LinqProtocol (LNQ) — a reference card for a crypto project: what the product does and how verifiable the project’s key claims are; also — alignment with the Decentralized AI thesis (DecAI Fit).

LinqAI — an AI/Compute / Infra project: the team develops “AI powered …” SaaS products and in parallel describes LinqProtocol as a decentralized compute marketplace, where smart contracts handle bidding/escrow/task orchestration, and offchain nodes execute the computations in containers. Token: LNQ (ERC‑20, Ethereum).

Disclaimer

Important: this page is a reference overview of the project. Within DecAIHub, we separately record a verification based on open sources within the AI thesis (what is real AI/onchain/why a token, and which sources this is based on).
This is not financial advice and not a recommendation to buy/sell/hold any asset. We do not assess price, returns, or entry/exit timing.
Conclusions are based on publicly available materials found as of the verification date. The absence of confirmation does not imply the absence of the technology.

TL;DR (for readers who are not into AI)

  • What it is: a marketplace of compute resources: requesters publish jobs, providers execute them on their own machines.
  • Who it’s for: SaaS/teams and developers who need cheap/scalable compute; hardware providers who want to monetize idle capacity.
  • Why onchain/token: smart contracts hold the escrow and the market rules; the LNQ token is used to pay for jobs and for provider staking (per the litepaper).

How it works (very briefly)

  1. The user does: publishes a compute task (job request) and deposits the payment into escrow.
  2. The system does: providers register and stake LNQ, accept/execute the job in a container; the job life cycle is recorded onchain.
  3. The user gets: the completed computation/result; the provider receives the payout after completion/absence of a dispute.
  4. Where the blockchain is: onchain — escrow/bidding/registry/job management (described in the litepaper) + the LNQ token on Ethereum.
  5. Token role (if any): payments for compute + provider stake/collateral (litepaper).

Quick links: AI thesis fit

Project passport

Field Value
Project name LinqAI / LinqProtocol
Also known as (aliases) LNQ; $LNQ; LinqProtocol
Logo (logo) ../assets/242_linqai_logo.svg
Token symbol (ticker) LNQ
Category AI/Compute | Infra
Primary chain (chain) Ethereum
Type EVM
Network status mainnet
Consensus (consensus) PoS (Ethereum)
Launch date (launch_date) 2024–2025 (litepaper: 2025‑02‑24)
Project status (status) active
Token (standard) ERC-20
Token contract 0xD4F4D0a10BcaE123bB6655E8Fe93a30d01eEbD04
Token model (token_type) utility (payments + staking + registry)
Max supply 1,000,000,000 LNQ (Etherscan Max Total Supply)
Issuance fixed (max supply)
Tokenomics (tokenomics, brief) LNQ is used as the escrow payment and the provider stake (litepaper)
Governance —
Admins/keys —
Audit yes (Hacken: LinqAI)
Bug bounty —
Team (team) —
Funding (investors/funding) —
AI component (ai_component) "AI powered" SaaS products (marketing/content/research)
Use‑case (use_case) decentralized compute marketplace
DecAI Fit — AI thesis fit 3/6 — medium alignment with the Decentralized AI thesis
DecAI Fit component summary 1 / 3 / 2 / 2
Last verified 2026-02-11

General project overview

LinqAI describes a set of “AI powered” SaaS products (marketing/content/research/design), and in the LinqProtocol Litepaper it formulates a separate technical goal: to build a decentralized compute marketplace that “sits” on an L2 and connects compute requesters with providers of idle hardware. The litepaper emphasizes a “SaaS‑demand‑first” approach: the network is to be loaded with real tasks (for example, synthetic data services) in order to remove the demand/supply bootstrap problem.

Features/modules

  • Smart contract layer: bidding + escrow payments + registry + job lifecycle (litepaper).
  • Offchain compute nodes: task execution in containers (litepaper).
  • Provider registration + staking: providers register and stake LNQ as collateral (litepaper).
  • UI/SDK (planned): dashboard/SDK/CLI for submitting jobs (litepaper).

Typical scenarios

  • Scenario 1: a requester publishes a compute task and deposits the payment → a provider executes the job → the requester receives the result.
  • Scenario 2: a hardware owner registers a node and stakes LNQ → receives jobs and payouts for the completed work.

Getting started (wallet/network)

  • What you need: an LNQ wallet (ERC‑20) for token operations; for the provider role — hardware/a node (details — in the litepaper).
  • Network/chain: Ethereum (LNQ token); LinqProtocol is described as an L2 marketplace (the specific L2 is not named in the litepaper).
  • Fees: gas in EVM networks for onchain operations (transfers/staking/contracts).

Architecture/tech (non‑AI)

  • Components: smart contracts for job management/escrow/registry + offchain compute nodes (containerized execution) + UI/SDK (planned).
  • Participant roles: requesters (compute requesters), providers (compute executors), the protocol operator/team (per the litepaper).
  • Where logic runs: onchain — escrow/market rules; offchain — compute execution.
  • Dependencies: EVM infrastructure (RPC, L2), container runtimes (described in the litepaper).

Token/economics (expanded, no forecasts)

  • Token utility: payment for compute (escrow) + provider staking/collateral (litepaper).
  • Protocol necessity drivers: requesters deposit LNQ for jobs; providers stake LNQ upon registration (litepaper).
  • Who pays fees: users/participants for onchain operations.
  • Where fees go: gas — to the validators/sequencers of the EVM network; payouts for compute — to providers (via escrow).
  • Issuance/burn: max supply 1B LNQ (Etherscan/CMC).
  • Security/incentive mechanisms: LNQ staking upon provider registration (collateral; the litepaper mentions the possibility of penalties/slashing for violations, but the parameters were not extracted).
  • Distribution and token issuance schedule: not found in Tier‑1 sources.
  • Treasury: not found in Tier‑1 sources.

Governance

  • Who makes decisions: not disclosed in Tier‑1 sources.
  • How protocol parameters change: —.
  • Where decisions are discussed/made: official publications (litepaper/blog) and the GitHub organization.
  • Keys/multisig: —.

Security and incidents

  • Audits: Hacken audit (the LinqAI audit page).
  • Bug bounty: —.
  • Incidents: not found in Tier‑1 sources.
  • Threat model: risks of the escrow/registry contracts, risks of validating offchain compute results and the risks of false “AI” claims without technical artifacts.

Project status and timeline

  • Current status: the LNQ token exists on Ethereum; the LinqProtocol litepaper is published.
  • Key releases/milestones: litepaper v0.0.1 (2025‑02‑24).
  • Roadmap: a “Roadmap” section is listed in the litepaper (Table of Contents).

Ecosystem/integrations

  • Integrations: EVM wallets/infrastructure; container runtimes for providers (litepaper).
  • Partners: not confirmed by Tier‑1 sources.
  • Where it’s actually used: the litepaper describes the target use‑case “synthetic data generation services” as seed workloads.

AI component of the project

  • What is real AI here? on the website, the product lines are labeled “AI powered …”, but without a detailed technical description of the models/metrics; in the litepaper, the main focus is the compute marketplace (not an “AI protocol”).
  • What is truly onchain? the LNQ token (ERC‑20) and the LinqProtocol onchain layer (escrow/bidding/registry/job management — per the litepaper).
  • Why is a token needed? payment for compute tasks via escrow and provider staking (litepaper).
  • Red flags (based on the information found): AI‑washing — high (AI is claimed, but there are few technical artifacts); what to double‑check — public demos/examples of the “AI powered” products and the specific L2/contracts of LinqProtocol.

DecAI Fit component summary

  • DecAI Fit: 3/6 — medium alignment with the Decentralized AI thesis
Component Level Score
AI reality low 1
Onchain necessity high 3
Token necessity medium 2
Evidence Tier‑1 present 2
Details

AI reality

AI_0 — AI intent (Tier‑1 roadmap) (1/0)

  • AI_0 (decision): 0
  • Claim (one line): there are “AI powered” product claims (AI_1), so this is not “intent only”.
  • Evidence: Tier‑1 — https://www.linqai.com/
  • Why sufficient / why not (one line): AI_0 applies when AI_1..AI_4 = 0.
  • Conflict note (if any): —

AI_1 — what the AI does (1/0)

  • AI_1 (decision): 1
  • Claim (one line): the website claims “AI powered” products for research/design and for marketing/content automation.
  • Evidence: Tier‑1 — https://www.linqai.com/
  • Why sufficient / why not (one line): the Tier‑1 wording records the presence of AI functions at the product level.
  • Conflict note (if any): the technical details of the models are not disclosed.

AI_2 — demos/examples (1/0)

  • AI_2 (decision): 0
  • Claim (one line): there are links to web products, but public examples/demos of AI quality were not confirmed within the check.
  • Evidence: Tier‑1 — https://www.linqai.com/
  • Why sufficient / why not (one line): without a verifiable example of a result — 0.
  • Conflict note (if any): —

AI_3 — metrics/quality (1/0)

  • AI_3 (decision): 0
  • Metrics: —
  • Context (version/date/how measured): —
  • Evidence: Tier‑1 — https://www.linqai.com/
  • Why sufficient / why not (one line): quality metrics/benchmarks are not published.
  • Conflict note (if any): —

AI_4 — tech description/architecture/versions (1/0)

  • AI_4 (decision): 0
  • Claim (one line): a tech description of the AI models/versions was not found in Tier‑1 (the litepaper describes the compute marketplace, not AI models).
  • Evidence: Tier‑1 — https://www.linqai.com/linqprotocol-litepaper.pdf
  • Why sufficient / why not (one line): there is a technical description of the compute protocol, but not of the AI architecture.
  • Conflict note (if any): —

Onchain necessity

OC_1 — contracts/addresses/chain (1/0)

  • OC_1 (decision): 1
  • Chain: Ethereum (ERC‑20 token); LinqProtocol is described as an L2 (the specific network is not named).
  • Addresses/identifiers: LNQ ERC‑20: 0xD4F4D0a10BcaE123bB6655E8Fe93a30d01eEbD04
  • Evidence: Tier‑1 — https://etherscan.io/token/0xD4F4D0a10BcaE123bB6655E8Fe93a30d01eEbD04
  • Why sufficient / why not (one line): the token address is confirmed by the explorer/CMC.
  • Conflict note (if any): the addresses of the LinqProtocol L2 contracts are not provided.

OC_2 — onchain beyond just a token (1/0)

  • OC_2 (decision): 1
  • What useful logic is onchain: bidding/escrow + provider registry + job management (described as the smart contract layer).
  • Evidence: Tier‑1 — https://www.linqai.com/linqprotocol-litepaper.pdf
  • Why sufficient / why not (one line): this is onchain logic beyond “just a token”.
  • Conflict note (if any): there is no SSOT of the protocol contract addresses.

OC_3 — onchain is critical (1/0)

  • OC_3 (decision): 1
  • “Replace the blockchain” test: without onchain escrow/registry, the market turns into a centralized service without trust-minimized guarantees of execution/payment.
  • Evidence: Tier‑1 — https://www.linqai.com/linqprotocol-litepaper.pdf
  • Why sufficient / why not (one line): the litepaper directly defines the contract layer as the “backbone” of the market.
  • Conflict note (if any): —

Token necessity

TK_0 — no token (1/0)

  • TK_0 (decision): 0
  • Claim (one line): the project has a token, LNQ (ERC‑20).
  • Evidence: Tier‑1 — https://etherscan.io/token/0xD4F4D0a10BcaE123bB6655E8Fe93a30d01eEbD04
  • Why sufficient / why not (one line): the token is confirmed by the explorer/CMC.
  • Conflict note (if any): —

TK_1..TK_4 (1/0)

TK_1 — payment for the service (1/0)

  • TK_1 (decision): 1
  • Claim (one line): payment for compute jobs is deposited into LNQ escrow and paid out to providers.
  • Evidence: Tier‑1 — https://www.linqai.com/linqprotocol-litepaper.pdf
  • Why sufficient / why not (one line): the litepaper describes “payment in LNQ deposited into escrow”.
  • Conflict note (if any): —

TK_2 — incentives/collateral/penalties (1/0)

  • TK_2 (decision): 1
  • Claim (one line): providers stake LNQ as collateral upon registration; penalties/slashing for violations are envisaged.
  • Evidence: Tier‑1 — https://www.linqai.com/linqprotocol-litepaper.pdf
  • Why sufficient / why not (one line): LNQ staking is described as “collateral to discourage malicious behavior”.
  • Conflict note (if any): the penalty parameters were not extracted.

TK_3 — governance (1/0)

  • TK_3 (decision): 0
  • Claim (one line): governance via LNQ in the litepaper/website is not confirmed in the extracted Tier‑1.
  • Evidence: Tier‑1 — https://www.linqai.com/linqprotocol-litepaper.pdf
  • Why sufficient / why not (one line): a governance section was not explicitly found in the available fragment.
  • Conflict note (if any): —

TK_4 — token is replaceable (1/0)

  • TK_4 (decision): 0
  • Claim (one line): the replaceability of the token is not proven in Tier‑1 (in the litepaper, the token is embedded in escrow and staking).
  • Evidence: Tier‑1 — https://www.linqai.com/linqprotocol-litepaper.pdf
  • Why sufficient / why not (one line): the token’s role is defined by the protocol.
  • Conflict note (if any): —

Evidence (table)

Tier Source What it proves
Tier‑1 https://www.linqai.com/linqprotocol-litepaper.pdf LinqProtocol onchain architecture (escrow/bidding/registry), LNQ utility (payments+staking)
Tier‑1 https://etherscan.io/token/0xD4F4D0a10BcaE123bB6655E8Fe93a30d01eEbD04 onchain SSOT of the LNQ token (ERC‑20)
Tier‑1 https://hacken.io/audits/linqai/ the fact of the LinqAI audit (Hacken)
Tier‑1 https://www.linqai.com/ claims about the “AI powered” product line
Tier‑2 https://coinmarketcap.com/currencies/linqai/ Aggregator: reference profile and links (not Tier‑1).
Tier‑2 https://www.coingecko.com/en/coins/linqai Aggregator: reference profile and links (not Tier‑1).

No comments to display

Back to top