Skip to main content

Akash Network

Akash Network (AKT) — 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).

Akash — a decentralized cloud compute marketplace (including GPU), where independent providers compete by offering resources and users (tenants) deploy containerized applications. AI/ML is treated as one of the key classes of workloads (GPU for training/inference), but Akash is not an “AI model” — it is compute infrastructure.

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 decentralized “cloud market” (compute marketplace) for deploying containers on the infrastructure of independent providers.
  • Who it’s for: developers/teams that need cheap and flexible infrastructure, and providers that lease out spare capacity.
  • Why onchain/token: the blockchain records orders/leases/payments and provides trustless accounting of provider history; the AKT token is used to pay for compute, for staking (network security) and for governance.
  • What you can actually touch (Tier‑1): there are step‑by‑step guides for deploying LLM applications (e.g. LocalAI/AnythingLLM) via SDL.

How it works (very briefly)

  1. The user does: describes a deployment (CPU/RAM/storage/GPU resources) and publishes an order on the network.
  2. The system does: providers place bids, the system forms a lease; the workload is deployed on the provider’s infrastructure.
  3. The user gets: a running application/job (including GPU workloads).
  4. Where the blockchain is: the Akash chain (PoS); the whitepaper describes an onchain marketplace + offchain execution of workloads.
  5. Token role: AKT for payments/settlement, staking (security) and voting on parameters (e.g. inflation/fees).

Quick links: AI thesis fit

Project passport

Field Value
Project name Akash Network
Also known as (aliases) Akash, AKT
Logo (logo) ../assets/akash_logo.svg
Token symbol (ticker) AKT
Category AI/Compute | Infra
Primary chain (chain) Akash
Type Appchain
Network status mainnet
Consensus (consensus) PoS (CometBFT)
Launch date (launch_date) —
Project status (status) active
Token (standard) native
Token contract native (no contract)
Token model (token_type) utility (payments + staking + governance)
Max supply ~389000000 (AKT; Mmax≈3.89×100000000)
Issuance inflationary (decay over time)
Tokenomics (tokenomics, brief) genesis 100000000; issuance up to Mmax is distributed to stakers
Governance DAO (onchain governance)
Admins/keys —
Audit —
Bug bounty —
Team (team) —
Funding (investors/funding) —
AI component (ai_component) decentralized GPU cloud for AI/ML workloads
Use‑case (use_case) compute/GPU rental for containers
DecAI Fit — AI thesis fit 5/6 — high alignment with the Decentralized AI thesis
DecAI Fit component summary 2 / 3 / 3 / 3
Last verified 2026-02-11

General project overview

Akash is positioned as a “decentralized cloud marketplace”: users deploy containers, providers compete on price and supply resources. The docs describe the basic flow (deploy → providers bid → an offer is selected → the application runs), and the whitepaper describes the split into onchain (orderbook/leases/accounting) and offchain (execution of workloads and P2P exchange of manifests).

From the “AI demo” standpoint, the Tier‑1 docs publish reproducible examples of deploying AI/LLM software (e.g. LocalAI and AnythingLLM) — this demonstrates a practical scenario of using Akash as a compute layer for AI workloads.

Features/modules

  • Marketplace (orders/bids/leases): the user publishes requirements, providers place bids, a lease is created.
  • SDL (deployment spec): a declarative description of the deployment and resource parameters.
  • Provider layer: providers manage the hardware and execute workloads.

Typical scenarios

  • Scenario 1 (web service deployment): a developer publishes an SDL → selects a bid → the service runs; pays “per block”.
  • Scenario 2 (AI/ML workloads): runs training/inference/LLM/diffusion in a container on GPU resources; Tier‑1 has specific guides (LocalAI/AnythingLLM) as an example.
  • Scenario 3 (provider): sets up a provider → participates in bidding → receives payment for leases.

Getting started (wallet/network)

  • What you need: an SDL and access to the console/CLI; for permissionless mode — a wallet and AKT.
  • Network/chain: Akash mainnet.
  • Fees: onchain network fees + payment for leases.

Architecture/tech (non‑AI)

  • Where logic runs: onchain — the marketplace and network parameters; offchain — containers/orchestration, the overlay network and exchange of manifests (whitepaper).
  • Participant roles: tenants, providers, validators/node operators.

Token/economics (expanded, no forecasts)

  • Security: the network is secured by PoS; AKT is used for staking and yields a return.
  • Governance: AKT holders govern network parameters (including inflation/fees).
  • Payments: the token page states that AKT is the only way to purchase compute (with traditional payments converted into AKT).
  • Supply/issuance: AEP‑22 refers to a genesis (M0=10^8) and a maximum supply (Mmax≈3.89·M0); (Mmax - M0) is distributed to stakers over the “lifetime” of the network.

Governance

Onchain governance: votes by AKT holders and updates of network parameters.

Security and incidents

  • Security advisories: an advisories page exists in the akash-network/node repository.
  • Audits / bug bounty: not found in Tier‑1 sources.

Project status and timeline

  • Current status: mainnet.
  • Roadmap: published on the website.

Ecosystem/integrations

  • Explorers: Mintscan/Atomscan/Ping.pub are listed on the token page.
  • Development: node code and releases are published on GitHub.

AI component of the project

  • What is real AI here? Akash provides compute/GPU infrastructure for AI/ML workloads (training/inference/LLMs), but does not itself implement ML models.
  • What is truly onchain? The marketplace and network parameters are onchain; execution of workloads is offchain.
  • Why is a token needed? AKT is needed to pay for compute, for staking and for governance.
  • Red flags (based on the information found): AI‑washing (this is infrastructure for AI, not an “AI protocol”); separately verify the current implementation of multi‑currency settlement. On the plus side: the Tier‑1 docs contain reproducible “demo/how‑to” (deployment of LocalAI/AnythingLLM).

DecAI Fit component summary

  • DecAI Fit: 5/6 — high alignment with the Decentralized AI thesis
Component Level Score
AI reality medium 2
Onchain necessity high 3
Token necessity high 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): AI/ML is described as a class of workloads; the intent flag is not used separately from AI_1/AI_2.
  • Evidence: Tier‑1 — https://akash.network/docs/getting-started/what-is-akash
  • Why sufficient / why not (one line): intent adds no signal when there are reproducible examples of deploying AI applications.
  • Conflict note (if any): —

AI_1 — what the AI does (1/0)

  • AI_1 (decision): 1
  • Claim (one line): Akash provides compute/GPU infrastructure for AI/ML workloads (training/inference/LLMs) without being an “AI model”.
  • Evidence: Tier‑1 — https://akash.network/docs/getting-started/what-is-akash
  • Why sufficient / why not (one line): Tier‑1 describes AI/ML workloads as a typical scenario of compute consumption.
  • Conflict note (if any): —

AI_2 — demos/examples (1/0)

  • AI_2 (decision): 1
  • Claim (one line): the Tier‑1 docs contain step‑by‑step guides for deploying AI/LLM applications (example: LocalAI/AnythingLLM) on Akash.
  • Evidence: Tier‑1 — https://akash.network/docs/guides/machine-learning/localai, https://akash.network/docs/guides/machine-learning/anythingllm
  • Why sufficient / why not (one line): these are reproducible examples (SDL + deploy/access steps) demonstrating AI workloads on the network.
  • Conflict note (if any): —

AI_3 — metrics/quality (1/0)

  • AI_3 (decision): 0
  • Metrics: —
  • Context (version/date/how measured): —
  • Evidence: Tier‑1 — https://akash.network/docs/
  • Why sufficient / why not (one line): this is a compute layer; AI quality metrics are not applicable.
  • Conflict note (if any): —

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

  • AI_4 (decision): 0
  • Claim (one line): there is no technical description of an AI architecture/model versions; there is an architecture of the network/providers.
  • Evidence: Tier‑1 — https://akash.network/docs/
  • Why sufficient / why not (one line): the AI component is not a separate protocol‑level entity.
  • Conflict note (if any): —

Onchain necessity

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

  • OC_1 (decision): 1
  • Chain: Akash mainnet
  • Addresses/identifiers: native coin AKT; the explorer is listed in links_*
  • Evidence: Tier‑1 — https://akash.network/token
  • Why sufficient / why not (one line): the token page describes AKT and the role of the PoS network.
  • Conflict note (if any): —

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

  • OC_2 (decision): 1
  • What useful logic is onchain: the onchain marketplace (orders/bids/leases) and accounting of transactions/provider history.
  • Evidence: Tier‑1 — https://ipfs.io/ipfs/QmVwsi5kTrg7UcUEGi5UfdheVLBWoHjze2pHy4tLqYvLYv
  • Why sufficient / why not (one line): the whitepaper describes the blockchain as a trust layer and an orderbook‑based marketplace.
  • Conflict note (if any): —

OC_3 — onchain is critical (1/0)

  • OC_3 (decision): 1
  • “Replace the blockchain” test: without trustless onchain accounting and the marketplace, Akash turns into an ordinary centralized compute marketplace.
  • Evidence: Tier‑1 — https://ipfs.io/ipfs/QmVwsi5kTrg7UcUEGi5UfdheVLBWoHjze2pHy4tLqYvLYv
  • Why sufficient / why not (one line): the key property is a market without an intermediary and public accounting of deals.
  • Conflict note (if any): —

Token necessity

TK_0 — no token (1/0)

  • TK_0 (decision): 0
  • Claim (one line): the project has a native token, AKT.
  • Evidence: Tier‑1 — https://akash.network/token
  • Why sufficient / why not (one line): the token page describes AKT as a native utility 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): AKT is stated to be the only way to purchase compute; traditional payments are converted into AKT.
  • Evidence: Tier‑1 — https://akash.network/token
  • Why sufficient / why not (one line): the token page explicitly says “AKT is the only way to purchase compute”.
  • Conflict note (if any): —

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

  • TK_2 (decision): 1
  • Claim (one line): AKT is used for staking (PoS security) and yields a return to stakers.
  • Evidence: Tier‑1 — https://akash.network/token
  • Why sufficient / why not (one line): the “Security” section describes AKT staking and yield.
  • Conflict note (if any): —

TK_3 — governance (1/0)

  • TK_3 (decision): 1
  • Claim (one line): AKT holders vote on network parameters (including inflation/fees).
  • Evidence: Tier‑1 — https://akash.network/token
  • Why sufficient / why not (one line): the “Governance” section describes onchain voting.
  • Conflict note (if any): —

TK_4 — token is replaceable (1/0)

  • TK_4 (decision): 0
  • Claim (one line): the Tier‑1 source states that compute is purchased via AKT (even when “traditional payments” are used).
  • Evidence: Tier‑1 — https://akash.network/token
  • Why sufficient / why not (one line): according to the project, AKT is built into the settlement mechanics of the network.
  • Conflict note (if any): —

Evidence (table)

Tier Source What it proves
Tier‑1 https://akash.network/docs/getting-started/what-is-akash description of the product and flow, including AI/ML workloads and GPU as a use case
Tier‑1 https://akash.network/docs/guides/machine-learning/localai a reproducible example of deploying an LLM API (LocalAI) on Akash (SDL + steps).
Tier‑1 https://akash.network/docs/guides/machine-learning/anythingllm a reproducible example of deploying an LLM application (AnythingLLM) on Akash (SDL + steps).
Tier‑1 https://ipfs.io/ipfs/QmVwsi5kTrg7UcUEGi5UfdheVLBWoHjze2pHy4tLqYvLYv whitepaper: marketplace, onchain/offchain model, token role
Tier‑1 https://akash.network/token AKT utility (payments/staking/governance) and its link to compute
Tier‑1 https://akash.network/roadmap/aep-22 supply parameters (M0=1e8, Mmax≈3.89·M0) and the mint model (decay; governance)
Tier‑1 https://github.com/akash-network/node/releases node releases/change history (Tier‑1 artifact)

No comments to display

Back to top