Skip to main content

GraphLinq

GraphLinq (GLQ) — 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).

GraphLinq — an Infra / Automation / AI/Tools ecosystem: a no‑code IDE/Engine/Marketplace for automations (“graphs”) + a separate EVM‑compatible network, GraphLinq Chain (PoA clique), as the execution layer; the GLQ token is used as gas/payment for executions and for governance (per the docs).

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 platform for no‑code automations in Web3 (bots/scripts/integrations) + its own network for executing these automations.
  • Who it’s for: developers and no‑code users who want to quickly assemble and run automations/bots and dApps.
  • Why onchain/token: GLQ is needed to pay for the execution of “graphs” and for transactions/operations on GraphLinq Chain; per the docs, part of the token/fees is expected to be burned.

How it works (very briefly)

  1. The user does: assembles an automation in the GraphLinq IDE (drag‑and‑drop “graphs”) or takes a template from the Marketplace.
  2. The system does: the GraphLinq Engine executes the nodes/blocks of the graph; per the docs, the engine runs on top of GraphLinq Chain.
  3. The user gets: a working automation (for example, monitoring/alerts/bots/operations with DEXes/contracts) without code.
  4. Where the blockchain is: GraphLinq Chain (PoA) acts as the execution layer and the transaction network; the GLQ token exists as the native asset of the network and as an ERC‑20 representation on Ethereum (for liquidity/the bridge).
  5. Token role: GLQ — gas/payment for graph executions and financial operations in the ecosystem; also claimed as a governance token.

Quick links: AI thesis fit

Project passport

Field Value
Project name GraphLinq
Also known as (aliases) GraphLinq Chain; GraphLinq Protocol; GraphLinq IDE; GraphAI (AI assistant, per the website/blog); GLQ
Logo (logo) ../assets/213_graphlinq-protocol_logo.webp
Token symbol (ticker) GLQ
Category AI/Tools | Infra | Automation
Primary chain (chain) Ethereum
Type EVM
Network status mainnet
Consensus (consensus) PoA (clique), block time ~15s
Launch date (launch_date) unknown (the extracted Tier‑1 pages contain no genesis/mainnet date; the docs were updated in 2024–2026)
Project status (status) active (IDE/App/Hub/Chain + docs)
Token (standard) ERC-20
Token contract ERC‑20 GLQ: 0x9f9c8ec3534c3ce16f928381372bfbfbfb9f4d24 (Etherscan)
Token model (token_type) utility (gas + fees for graph execution + DAO governance)
Max supply 500,000,000 GLQ (minted at deploy, per the code on Etherscan); Etherscan shows ~500M max total
Issuance mixed/unclear: the ERC‑20 was issued with a fixed mint; for the network, block rewards (5 GLQ/block) and burning of gas tokens are claimed (per the docs)
Tokenomics (tokenomics, brief) GLQ pays for “graph” executions; the docs claim burning of the tokens used as gas for executions; block rewards 5 GLQ/block (per the chain specs)
Governance DAO governance is claimed in the docs
Admins/keys a PoA network implies a set of authority validators; details of validator/key management not extracted
Audit yes: the GitBook lists an Audit Report (Solidproof repo)
Bug bounty unknown
Team (team) unknown (the extracted sources contain no roster/legal entity)
Funding (investors/funding) unknown
AI component (ai_component) AI assistant for graph building (OpenAI-based)
Use‑case (use_case) no-code Web3 automation + execution chain
DecAI Fit — AI thesis fit 3/6 — medium alignment with the Decentralized AI thesis
DecAI Fit component summary 1 / 2 / 3 / 3
Last verified 2026-02-11

General project overview

GraphLinq positions itself as an ecosystem for “no‑code” automations in Web3: users build “graphs” (scenarios made of blocks/nodes) in the IDE, can use ready‑made templates from the Marketplace and run them via the App/Engine. The official GitBook documentation says that the Engine executes automations and “runs on the GraphLinq Chain”, and that the GraphLinq Chain network itself was created specifically to support the protocol.

Separately, the project promotes an AI assistant for building graphs (the website explicitly says “AI‑bot based on OpenAI”). This is more of an AI add‑on over the IDE/blocks than “decentralized AI” in the sense of onchain inference/models.

Features/modules

  • GraphLinq IDE: a visual automation editor (drag‑and‑drop).
  • GraphLinq App: an interface for running/monitoring dApps and executions.
  • GraphLinq Engine: executes the nodes/blocks of automations; per the docs, it runs on top of GraphLinq Chain.
  • Marketplace: .GLQ templates / ready‑made automations.
  • GraphLinq Chain: a separate network (PoA clique) for execution/transactions, with chain ID 614 and block rewards (per the docs).
  • AI assistant: a “personal AI assistant” for building graphs, claimed as OpenAI‑based.

Typical scenarios

  • Scenario 1: a user assembles a graph for price monitoring/alerts → runs it → receives notifications/automatic actions.
  • Scenario 2: a user builds a trading bot or a workflow (DEX/bridge/contracts) via blocks → pays GLQ for executions.
  • Scenario 3: a developer publishes a .GLQ template in the Marketplace → other users deploy it via the wizard and configure the variables.

Getting started (wallet/network)

  • What you need: a wallet (MetaMask/WalletConnect, etc. — per the website), access to the GraphLinq IDE/App.
  • Network/chain: GraphLinq Chain (chain id 614, PoA clique) for executions/operations; GLQ also exists on Ethereum as an ERC‑20 (for trading/the bridge).
  • Fees: GLQ is used as the “native asset” to pay for executions/fees (per the docs); network fees and the cost of executions depend on the complexity of the graph (per the website).

Architecture/tech (non‑AI)

  • Components: GraphLinq Chain (an EVM‑compatible PoA network), explorer/RPC, IDE/App/Engine/Marketplace (GitBook).
  • Participant roles: users (create/run graphs), engine operators (there are docs on running the engine locally), validators/authority nodes (PoA clique).
  • Where logic runs: workflow execution — via the Engine; per the docs, the engine “runs on GraphLinq Chain”. At the same time, many “blocks” integrate external services/data sources, i.e. part of the logic is inevitably offchain.
  • Dependencies: RPC/Explorer, bridge (GraphLinq Chain <> Ethereum), external data sources/plugins, wallet connections.

Token/economics (expanded, no forecasts)

  • Token utility: GLQ is the “native asset of GraphLinq Chain”; it is used to pay for graph executions and financial transactions; DAO governance is also claimed (GitBook).
  • Protocol necessity drivers: without GLQ, protocol executions/fees cannot be paid for (per the docs).
  • Who pays fees: users who run graphs/execute transactions on the network.
  • Where fees go: the docs claim burning of the tokens used as gas fees to pay for graphs; at the same time, the chain specs claim block rewards of 5 GLQ/block (requires a separate reconciliation of the actual economy against onchain data/current releases).
  • Issuance/burn: ERC‑20 GLQ: a mint of 500M to the deployer (per the code on Etherscan) + burnFuel; for the network: block rewards of 5 GLQ/block + the claimed burn of gas tokens (GitBook).
  • Security/incentive mechanisms: PoA consensus; the docs mention rewards for staking/validating/running the engine (links in the GitBook).
  • Distribution and token issuance schedule: allocation/rewards tables were not extracted (there is an Allocation section in the GitBook).
  • Treasury: unknown.

Governance

  • Who makes decisions: DAO governance via GLQ is claimed (GitBook).
  • How protocol parameters change: the DAO mechanism is not described in the extracted fragments (the governance docs/contracts need to be examined separately).
  • Where decisions are discussed/made: GitBook + Medium/social media.
  • Keys/multisig: for a PoA network, the key factor is the management of the authority set; there are no details in the extracted Tier‑1.

Security and incidents

  • Audits: the GitBook links to the Solidproof audit repo with PDF reports (GraphLinq / GraphLinqChain).
  • Bug bounty: unknown.
  • Incidents: public post‑mortems were not extracted.
  • Threat model: PoA risks (validator centralization), risks of “blocks” integrations with external sources and bridge risks (GraphLinq Chain <> Ethereum).

Project status and timeline

  • Current status: mainnet (GraphLinq Chain specs in the docs); the IDE/App/Engine are available per the website/docs.
  • Key releases/milestones: the blog has “GraphLinq 2021–2025” and recap posts; exact versions/releases of the chain client were not extracted.
  • Roadmap: there is no separate roadmap page in links_*; the blog has “recap/milestones” and “coming soon” about Terminal.

Ecosystem/integrations

  • Integrations: IDE/App/Hub, bridge, explorer, public RPC; examples of integrations via blocks (DEXes/exchanges/contracts) — per the descriptions in the docs/website.
  • Partners: the GitBook mentions Solidproof (audit report link); the rest — without explicit contractual confirmations.
  • Where it’s actually used: automation of actions in DeFi/Web3 (monitoring/executions/bots) and running no‑code templates.

AI component of the project

  • What is real AI here? the AI part in Tier‑1 is described as an assistant for building graphs (“AI‑bot based on OpenAI” / “personal AI assistant”) and AI marketing around GraphAI/Terminal.
  • What is truly onchain? GraphLinq Chain as the execution network (PoA) + the GLQ token (the network’s native asset) and ERC‑20 GLQ on Ethereum; onchain transactions and payment for executions.
  • Why is a token needed? GLQ pays for executions/fees and is claimed as DAO governance; the docs also claim burning of the tokens used as gas for executions.
  • Red flags (based on the information found): AI‑washing — medium (the AI assistant is tied to OpenAI, this is not “decentralized AI”); onchain‑washing — medium (many integrations and much of the logic remain offchain via plugins/blocks); token‑washing — below medium (the token is needed as gas/fees for executions, per the docs).

DecAI Fit component summary

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

AI reality

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

  • AI_0 (decision): 0
  • Claim (one line): There are signs of AI reality per Tier‑1 (see AI_1..AI_4), so the AI_0 flag (intent‑only) does not apply.
  • Evidence: Tier‑1 — see Evidence/links in AI_1..AI_4.
  • Why sufficient / why not (one line): AI_0=1 is admissible only when AI_1..AI_4=0; here ai_score without AI_0 = 1.
  • Conflict note (if any): —

AI_1 — what the AI does (1/0)

  • AI_1 (decision): 1
  • Claim (one line): the AI assistant helps the user build graphs/automations; claimed as OpenAI‑based.
  • Evidence: Tier‑1 — https://graphlinq.io/
  • Why sufficient / why not (one line): the website directly describes a “personal AI assistant” and an “AI‑bot based on OpenAI”.
  • Conflict note (if any): this is API‑dependent AI (a centralized model), not onchain AI.

AI_2 — demos/examples (1/0)

  • AI_2 (decision): 0
  • Claim (one line): public demos specifically of the “AI assistant” are not confirmed by artifacts/repositories in the extracted Tier‑1 sources; there are only links to products.
  • Evidence: Tier‑1 — https://graphlinq.io/
  • Why sufficient / why not (one line): the presence of links to AI pages does not equal a verifiable demo/repo/metrics.
  • Conflict note (if any): —

AI_3 — metrics/quality (1/0)

  • AI_3 (decision): 0
  • Metrics: —
  • Context (version/date/how measured): —
  • Evidence: Tier‑1 — https://graphlinq.io/
  • Why sufficient / why not (one line): no metrics of the quality/accuracy/cost of the AI assistant’s operation are published in the extracted Tier‑1.
  • Conflict note (if any): —

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

  • AI_4 (decision): 0
  • Claim (one line): the AI part is described at the level of “OpenAI‑based assistant/agents”, without architecture/versions/a repo in the extracted sources.
  • Evidence: Tier‑1 — https://graphlinq.io/
  • Why sufficient / why not (one line): there are not enough details to verify the AI component (code, versions, reproducible results).
  • Conflict note (if any): —

Onchain necessity

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

  • OC_1 (decision): 1
  • Chain: GraphLinq Chain mainnet (chain id 614); ERC‑20 GLQ on Ethereum.
  • Addresses/identifiers: chain id 614 (docs); ERC‑20 GLQ: 0x9f9c8ec3534c3ce16f928381372bfbfbfb9f4d24
  • Evidence: Tier‑1 — https://docs.graphlinq.io/graphlinq-chain/networks/specs ; https://etherscan.io/token/0x9f9c8ec3534c3ce16f928381372bfbfbfb9f4d24
  • Why sufficient / why not (one line): there are official chain specs and an onchain token address.
  • Conflict note (if any): —

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

  • OC_2 (decision): 1
  • What useful logic is onchain: per the docs, GraphLinq Chain was created as the platform on which the Engine runs and automations/transactions are executed.
  • Evidence: Tier‑1 — https://docs.graphlinq.io/ ; https://docs.graphlinq.io/graphlinq-chain/networks/specs
  • Why sufficient / why not (one line): the onchain part is confirmed as the execution layer, but most “blocks” interact with external systems.
  • Conflict note (if any): PoA consensus reduces the degree of decentralization compared to PoS/PoW.

OC_3 — onchain is critical (1/0)

  • OC_3 (decision): 0
  • “Replace the blockchain” test: without the chain, a similar workflow engine can be implemented in Web2; onchain adds a payment model/publicity, but it is not proven that “the product is impossible without the blockchain”.
  • Evidence: Tier‑1 — https://docs.graphlinq.io/
  • Why sufficient / why not (one line): the extracted sources contain no strict justification that onchain is critical (rather a design choice).
  • Conflict note (if any): —

Token necessity

TK_0 — no token (1/0)

  • TK_0 (decision): 0
  • Claim (one line): GLQ is the native asset of GraphLinq Chain and a token on Ethereum (ERC‑20).
  • Evidence: Tier‑1 — https://docs.graphlinq.io/graphlinq-chain/glq ; https://etherscan.io/token/0x9f9c8ec3534c3ce16f928381372bfbfbfb9f4d24
  • Why sufficient / why not (one line): the docs/explorer confirm the existence of the token.
  • 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): GLQ is used to pay for graph executions and financial transactions in the protocol/network.
  • Evidence: Tier‑1 — https://docs.graphlinq.io/graphlinq-chain/glq
  • Why sufficient / why not (one line): the docs directly describe GLQ as the token for fees/executions.
  • Conflict note (if any): —

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

  • TK_2 (decision): 1
  • Claim (one line): the network has block rewards (5 GLQ/block), and rewards for staking/validating/running the engine are also mentioned (GitBook).
  • Evidence: Tier‑1 — https://docs.graphlinq.io/graphlinq-chain/networks/specs ; https://docs.graphlinq.io/
  • Why sufficient / why not (one line): the chain specs confirm the block reward; the docs list rewards mechanics as part of the ecosystem.
  • Conflict note (if any): the details of the economy require extended verification (contracts/addresses/parameters).

TK_3 — governance (1/0)

  • TK_3 (decision): 1
  • Claim (one line): GLQ is claimed as a DAO governance token.
  • Evidence: Tier‑1 — https://docs.graphlinq.io/graphlinq-chain/glq
  • Why sufficient / why not (one line): the docs directly assert the governance role of the token.
  • Conflict note (if any): specific governance contracts not extracted.

TK_4 — token is replaceable (1/0)

  • TK_4 (decision): 0
  • Claim (one line): if desired, fees/execution payment could also be implemented in a different model, so the “irreplaceability” of the token is not proven.
  • Evidence: Tier‑1 — https://docs.graphlinq.io/graphlinq-chain/glq
  • Why sufficient / why not (one line): the docs describe the necessity of GLQ within their design, but irreplaceability is not proven.
  • Conflict note (if any): —

Evidence (table)

Tier Source What it proves
Tier‑1 https://docs.graphlinq.io/ Description of the ecosystem (IDE/App/Engine/Marketplace) and of GraphLinq Chain as a PoA network for the protocol; links to the audit report.
Tier‑1 https://docs.graphlinq.io/graphlinq-chain/networks/specs Chain specs: PoA (clique), 15s block time, block reward 5 GLQ, chain id 614.
Tier‑1 https://docs.graphlinq.io/graphlinq-chain/glq Role of GLQ: fees/executions, gas burn, DAO governance.
Tier‑1 https://graphlinq.io/ Product page: no‑code IDE, AI assistant (OpenAI‑based), staking/hub and automation cases.
Tier‑1 https://etherscan.io/token/0x9f9c8ec3534c3ce16f928381372bfbfbfb9f4d24 ERC‑20 GLQ on Ethereum: supply ~500M, code (mint at deploy, burnFuel), basic links.
Tier‑1 https://github.com/solidproof/Projects/tree/main/GraphLinq Existence of audit PDF reports (Solidproof repo: GraphLinq and GraphLinqChain).
Tier‑2 https://www.coingecko.com/en/coins/graphlinq-protocol Reference profile (market/links), does not confirm the architecture.
Tier‑3 https://coinmarketcap.com/currencies/graphlinq-protocol/ Reference aggregator.

No comments to display

Back to top