Skip to main content

NEAR Protocol

NEAR Protocol — 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).

NEAR Protocol — an L1/Infra project, token (symbol: NEAR).

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: an L1 blockchain and a platform for smart contracts and dApps.
  • Who it’s for: application developers, dApp users, validators/infrastructure operators.
  • Why onchain/token: the network stores application state and executes contracts; the NEAR token is used to pay for operations (fees), for staking and for security/governance mechanisms.

How it works (very briefly)

  1. The user does: sends transactions and interacts with smart contracts (dApps).
  2. The system does: validators confirm and finalize blocks; contracts are executed on the network.
  3. The user gets: a state change (transfer, contract call, data write) with public verifiability.
  4. Where the blockchain is: storage of account/contract state and execution of protocol rules — onchain.
  5. Token role: payment of fees/resources, staking for network security, participation in governance processes (as described in Tier‑1).

Quick links: AI thesis fit

Project passport

Field Value
Project name NEAR Protocol
Also known as (aliases) NEAR
Logo (logo) ../assets/near_logo.svg
Token symbol (ticker) NEAR
Category AI/Other | Infra
Primary chain (chain) NEAR
Type Appchain
Network status mainnet
Consensus (consensus) PoS (Nightshade)
Launch date (launch_date) 2020-04-22
Project status (status) active
Token (standard) native
Token contract —
Token model (token_type) utility (fee-mechanism)
Max supply not capped (inflation ≤ 5%/year; may become deflationary when fees are burned)
Issuance inflationary (target max ~5%/year; fees partially burn)
Tokenomics (tokenomics, brief) NEAR is used for fees (gas/resources), validator staking, and is described as participating in governance processes; part of the fees is burned (Tier‑1).
Governance company/foundation (governance process; NEAR Foundation as coordinator at the early stage)
Admins/keys —
Audit yes
Bug bounty yes
Team (team) NEAR Foundation
Funding (investors/funding) —
AI component (ai_component) AI initiatives/agents in ecosystem
Use‑case (use_case) L1 for dApps + AI agents/AI apps
DecAI Fit — AI thesis fit 3/6 — medium alignment with the Decentralized AI thesis
DecAI Fit component summary ai_score 1 / onchain_score 3 / token_score 3 / evidence_score 3
Last verified 2026-02-10

General project overview

NEAR is an L1 blockchain and a smart contract platform designed for developing and running decentralized applications. It provides a validator network, onchain contract execution, and storage of account/contract state. The ecosystem includes developer tools and a public explorer for verifying network activity.

Features/modules

  • Smart contracts and accounts: onchain execution and state storage.
  • Sharding: scaling via the Nightshade architecture (described in the Tier‑1 whitepaper).
  • Developer tools and ecosystem: SDKs/repositories and documentation.

Typical scenarios

  • Scenario 1: a user interacts with a dApp/contract → gets an onchain result (transaction/state change).
  • Scenario 2: a developer deploys a contract and updates the application logic → the application runs onchain.
  • Scenario 3: a validator stakes NEAR and participates in validation → receives rewards according to the network rules.

Getting started (wallet/network)

  • What you need: a NEAR account/wallet and access to the application/developer tools.
  • Network/chain: NEAR mainnet.
  • Fees: operations on the network are paid in NEAR (fees/gas); part of the fees is burned (Tier‑1 whitepaper).

Architecture/tech (non‑AI)

  • Components: the validator/node network, protocol-level onchain execution, the reference client/codebase (nearcore), the explorer.
  • Participant roles: users, developers, validators, infrastructure operators.
  • Where logic runs: the core network rules and state — onchain; frontend/integrations — offchain.
  • Dependencies: — (integrations and external services depend on the specific dApp).

Token/economics (expanded, no forecasts)

  • Token utility: payment of network fees/resources (transactions + storage), staking for participation in validation and security.
  • Who pays fees: users (or the application “on behalf of the user”, if it implements such a model).
  • Where fees go: part of the fees is burned; validator rewards are formed through issuance/network mechanisms (Tier‑1 whitepaper).
  • Issuance/burn: an inflationary model with a target upper level (the whitepaper mentions max inflation of ~5%/year) and burning of part of the fees.
  • Security/incentive mechanisms: Proof of Stake (validators stake NEAR; the slashing mechanism for violating network rules is described in the whitepaper).

Governance

  • Who makes decisions: changes to specifications/standards are formalized through the NEP (NEAR Enhancement Proposals) process in the official NEPs repository.
  • How protocol parameters change: through changes to specifications/standards (NEPs) and changes/releases of the reference client (nearcore).

Security and incidents

  • Audits: there is an external audit (see links_*).
  • Bug bounty: there is a public program (see links_*).
  • Incidents: —.
  • System model: L1 specifics include client/protocol behavior and rules for validators (including slashing / double signing; see the whitepaper).

Project status and timeline

  • Current status: mainnet.
  • Key releases/milestones: reference client releases are published in nearcore releases (see links_*).
  • Roadmap: nearcore milestones (see links_*).

Ecosystem/integrations

  • Integrations: —.
  • Partners: —.
  • Where it’s actually used: network activity is observable via the explorer (see links_*).

AI component of the project

  • What is real AI here? The NEAR Tier‑1 documentation has a separate AI section (NEAR AI / agents), but it describes initiatives/layers in the ecosystem, not proof of an AI component at the level of the base L1 protocol.
  • What is truly onchain? An L1 network: onchain execution of smart contracts and state storage.
  • Why is a token needed? fees (gas/resources), validator staking for network security, and participation in governance processes (per Tier‑1).
  • Red flags (based on the information found): substituting “ecosystem AI initiatives” for an “AI component of the base protocol”; claims about AI functionality without Tier‑1 artifacts at the protocol/product level.

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 high 3
Evidence Tier‑1 present 3
Details

AI reality

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

  • AI_0 (decision): 1
  • Claim (one line): The NEAR Tier‑1 documentation has an AI section (NEAR AI / agents) as a declared applicability/direction.
  • Evidence: Tier‑1 — https://docs.near.org/ai/introduction
  • Why sufficient / why not (one line): This confirms AI intent/applicability, but does not prove an AI component at the level of the base L1 protocol.
  • Conflict note (if any): —

AI_1 — what the AI does (1/0)

  • AI_1 (decision): 0
  • Claim (one line): Tier‑1 does not confirm an “AI component of the base NEAR protocol”; AI is described as initiatives/layers in the ecosystem.
  • Evidence: Tier‑1 — https://docs.near.org/ai/introduction
  • Why sufficient / why not (one line): AI_1 requires Tier‑1 artifacts about what exactly “the AI does” as part of the product/protocol; here it is about applicability/ecosystem.
  • Conflict note (if any): —

AI_2 — demos/examples (1/0)

  • AI_2 (decision): 0
  • Claim (one line): Demos/examples of AI work specifically as part of the base NEAR protocol are not recorded in Tier‑1.
  • Evidence: Tier‑1 — https://docs.near.org/ai/introduction
  • Why sufficient / why not (one line): The AI section describes a direction, but does not provide a “demo of a protocol-level AI component”.
  • Conflict note (if any): —

AI_3 — metrics/quality (1/0)

  • AI_3 (decision): 0
  • Metrics: —
  • Context (version/date/how measured): —
  • Evidence: Tier‑1 — https://docs.near.org/ai/introduction
  • Why sufficient / why not (one line): There are no Tier‑1 quality metrics for an AI subsystem at the base protocol level.
  • Conflict note (if any): —

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

  • AI_4 (decision): 0
  • Claim (one line): There is a technical description of the NEAR L1 protocol, but not a technical description of an “AI component of the protocol”.
  • Evidence: Tier‑1 — https://pages.near.org/papers/the-official-near-white-paper
  • Why sufficient / why not (one line): The whitepaper describes the protocol/consensus/sharding, not an AI module of the protocol.
  • Conflict note (if any): —

Onchain necessity

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

  • OC_1 (decision): 1
  • Chain: NEAR mainnet
  • Addresses/identifiers: — (in this card we record the existence of the network/explorer; specific IDs depend on the entity)
  • Evidence: Tier‑1 — https://explorer.near.org/ ; https://pages.near.org/papers/the-official-near-white-paper
  • Why sufficient / why not (one line): The existence of a mainnet and an official explorer confirms the onchain network and an observable state.
  • Conflict note (if any): —

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

  • OC_2 (decision): 1
  • What useful logic is onchain: smart contracts/accounts/state storage and execution of transactions according to protocol rules.
  • Evidence: Tier‑1 — https://docs.near.org/ ; https://pages.near.org/papers/the-official-near-white-paper
  • Why sufficient / why not (one line): This is an L1 for contract execution and state storage, not a “token on a chain”.
  • Conflict note (if any): —

OC_3 — onchain is critical (1/0)

  • OC_3 (decision): 1
  • “Replace the blockchain” test: without the blockchain, the trusted model of contract execution/consensus and the public verifiability of state break down.
  • Evidence: Tier‑1 — https://pages.near.org/papers/the-official-near-white-paper
  • Why sufficient / why not (one line): The product = an L1 protocol; moving it offchain means replacing the very foundation.
  • 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, NEAR.
  • Evidence: Tier‑1 — https://pages.near.org/papers/the-official-near-white-paper
  • Why sufficient / why not (one line): The whitepaper describes the role of the NEAR token in the system.
  • 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): NEAR is used to pay for transaction execution and data storage (fees/storage).
  • Evidence: Tier‑1 — https://pages.near.org/papers/the-official-near-white-paper
  • Why sufficient / why not (one line): The whitepaper explicitly states: the NEAR token is used to pay for processing transactions and storing data.
  • Conflict note (if any): —

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

  • TK_2 (decision): 1
  • Claim (one line): Validators stake NEAR; slashing is applied for malicious behavior (for example, double signing).
  • Evidence: Tier‑1 — https://pages.near.org/papers/the-official-near-white-paper
  • Why sufficient / why not (one line): The whitepaper describes PoS/staking and the slashing conditions as a security mechanism.
  • Conflict note (if any): —

TK_3 — governance (1/0)

  • TK_3 (decision): 1
  • Claim (one line): The whitepaper describes the participation of the NEAR token in governance processes.
  • Evidence: Tier‑1 — https://pages.near.org/papers/the-official-near-white-paper
  • Why sufficient / why not (one line): It is stated that the token helps participate in governance processes (as part of network coordination).
  • Conflict note (if any): —

TK_4 — token is replaceable (1/0)

  • TK_4 (decision): 0
  • Claim (one line): The token does not look replaceable without changing the trusted L1 model (fees+staking/security+governance).
  • Evidence: Tier‑1 — https://pages.near.org/papers/the-official-near-white-paper
  • Why sufficient / why not (one line): In the whitepaper the token is embedded in the economy/security of the protocol; “replacing it with a subscription/USDC” changes the network mechanics.
  • Conflict note (if any): —

Evidence (table)

Tier Source What it proves
Tier‑1 https://near.org/blog/near-mainnet-genesis Launch date: MainNet genesis block (2020‑04‑22) and the MainNet: POA announcement (2020‑05‑04).
Tier‑1 https://docs.near.org/ Official documentation on the network/development (L1 context, contracts, tools).
Tier‑1 https://pages.near.org/papers/the-official-near-white-paper L1 model: PoS, Nightshade, the role of the NEAR token (fees/storage/staking/governance), economic parameters and burn.
Tier‑1 https://explorer.near.org/ The existence of a mainnet and an observable onchain state via the official explorer.
Tier‑1 https://github.com/near/nearcore Open implementation of the protocol (reference client).
Tier‑1 https://github.com/near/nearcore/releases Releases/changes of the reference client (development life cycle).
Tier‑1 https://docs.near.org/ai/introduction AI intent/applicability: an AI section in the Tier‑1 documentation (NEAR AI / agents).
Tier‑1 https://near.github.io/NEPs/neps/nep-0001.html The NEP (NEAR Enhancement Proposals) process: how changes to ecosystem and protocol specifications/standards are formalized.
Tier‑1 https://hacken.io/audits/near/l1-near-nearcore-oct2023/ The existence of an audit (external report).
Tier‑1 https://hackenproof.com/near/near-protocol The existence of a bug bounty program.

No comments to display

Back to top