Technical documentation for builders and integrations. SDK examples are conceptual / planned — no public SDK exists yet.
ANCHOR is a shared utility token that AI agents use to pay for network resources — compute, memory, APIs, data and settlement. Instead of every agent launching its own token, all agents share one metered utility layer.
Agents spend ANCHOR per action. Resource providers receive ANCHOR for capacity. Protocol fees route to buyback-and-burn, the real-asset treasury, and capacity rewards.
Action — any discrete, metered consumption of network resources (an API call, a memory write, a compute job, a settlement).
Metered fee — the ANCHOR price of an action, set per resource class and modulated by load, priority and reputation.
Reputation — a portable, verifiable track record per agent that unlocks capacity rewards and lower effective rates.
Reference floor — a treasury-backed reference metric. Informational, not a guaranteed market price.
The integration flow is designed to take minutes: create an agent wallet, fund it with ANCHOR, install the SDK (planned), and execute metered actions.
The example below is conceptual — the SDK is planned and not yet published.
import { Anchor } from "@anchor-protocol/sdk"
const anchor = new Anchor({
wallet: agentWallet,
})
const action = await anchor.execute({
resource: "compute",
units: 420,
})
console.log(action.cost) // metered ANCHOR costEvery consumption of network resources is an action with a metered fee. Actions are priced deterministically by the metering layer based on resource class, units consumed and agent tier.
Illustrative demo magnitudes: API call 0.0004 ANCHOR, memory write 0.0008 ANCHOR, compute job 0.0042 ANCHOR, agent settlement 0.0018 ANCHOR. Final pricing is TBD.
Payments are settled in ANCHOR per action. Agent wallets authorize payment at request time within operator-defined spending policies: per-action caps, per-period budgets and counterparty allow-lists.
Settlement is designed to complete in seconds for standard actions, with deferred settlement windows for high-volume agents.
Protocol fees split three ways: buyback-and-burn, the real-asset treasury, and capacity rewards. The split percentages are TBD pending final economic design.
Routing is executed on-chain and publicly verifiable.
The treasury accumulates tokenized exposure to external assets supporting the agent economy: cloud infrastructure, semiconductors, data infrastructure and AI infrastructure.
Custody structure, asset selection criteria and disclosure cadence are TBD. No specific holdings are implied.
A portion of fees purchases ANCHOR on the open market and permanently removes it from circulation. Burns are on-chain and verifiable.
Burn is a supply mechanism, not a price guarantee.
High-reputation agents receive rebates that lower their effective usage rates. Better performance leads to better rates, enabling more work.
Rebate formulas and tier thresholds are TBD.
Each agent accumulates a verifiable record: jobs completed, success rate, dispute frequency, response times and resource efficiency.
Reputation is designed to be portable across marketplaces and counterparties. Sybil-resistance design is TBD.
The ANCHOR SDK (planned) wraps wallet management, action metering and payment authorization behind a single client. All SDK examples in this documentation are conceptual.
import { Anchor } from "@anchor-protocol/sdk"
const anchor = new Anchor({
wallet: agentWallet,
policy: {
maxPerAction: "0.01",
maxPerHour: "1.0",
},
})Frameworks integrate ANCHOR by wrapping resource calls with metered execution. Each call declares a resource class and units; the SDK prices, authorizes and settles the action.
const result = await anchor.execute({
resource: "api",
provider: "data-provider-01",
units: 1,
meta: { endpoint: "/market-data" },
})Agent wallets separate custody from spending authority. The operator (or owner) holds custody; the agent receives delegated spending rights within strict policy limits.
Wallet standards and reference implementations are planned.
Actions are metered by the protocol, not by the client. The metering layer returns a deterministic price for each request, which the wallet authorizes before execution.
const quote = await anchor.quote({
resource: "memory",
units: 1024,
})
if (quote.cost <= policy.maxPerAction) {
await anchor.execute({ ...quote })
}Request → quote → authorization → execution → settlement → fee routing. The full lifecycle is designed to complete in seconds for standard actions.
The public API reference will be published alongside the SDK. Endpoints are planned for quoting, execution, settlement status, reputation queries and treasury disclosures.
This section is a placeholder — no public API exists yet.
Planned webhook events include action.settled, action.failed, policy.threshold_reached and reputation.tier_changed. Event payloads and signing scheme are TBD.
Expected error classes: INSUFFICIENT_BALANCE, POLICY_EXCEEDED, PROVIDER_UNAVAILABLE, METERING_TIMEOUT and SETTLEMENT_FAILED. Clients should treat metering timeouts as non-executed and retry with idempotency keys.
try {
await anchor.execute({ resource: "compute", units: 420 })
} catch (err) {
if (err.code === "POLICY_EXCEEDED") {
// escalate to operator
}
}A research agent consumes API calls for data retrieval and memory writes for its knowledge base. Typical action mix: high API volume, low compute.
const sources = await anchor.execute({
resource: "api",
units: 12,
})
await anchor.execute({
resource: "memory",
units: 256,
meta: { kind: "summary" },
})A coding agent is compute-heavy: sandboxed execution, test runs and static analysis. Compute jobs dominate its cost profile.
const run = await anchor.execute({
resource: "compute",
units: 4200,
meta: { runtime: "sandbox", timeoutMs: 30000 },
})Enterprise fleets run many agents under one treasury, with centralized spending policies and consolidated settlement reporting.
A fully autonomous service — such as a robotics operator — settles its own resource consumption continuously, building reputation that lowers its effective rates over time.
Contract addresses will be published at launch. No contract addresses exist yet — any address claiming to be ANCHOR before official publication should be treated as fraudulent.
Target deployment chains are TBD. The protocol is designed to be deployable where agent density and resource providers concentrate.
Audit scope, validator design and formal verification plans are TBD. No security guarantees are made prior to completed audits.
Protocol parameters are expected to transition from foundation-controlled configuration to on-chain governance as the network matures. Governance design is TBD.