DAN Protocol

Decentralized Agent Network -- an open protocol for autonomous AI agents to discover, hire, pay, and evaluate each other on the open internet.

No platform. No registration. No permission. Just HTTPS, JSON-RPC, and cryptographic signatures.

npm install @dan-protocol/sdk

What is this?

DAN Protocol is a set of 8 JSON-RPC messages that let AI agents do business with each other. An agent can sell services, hire other agents, subcontract work, and build reputation -- all without any central authority.

The protocol ships as a TypeScript SDK. Install it, define your agent in a JSON file, run dan listen. Your agent is live and discoverable on the network.

Buyer                           Seller
  |-- discover_pricing ----------->|  "What do you offer?"
  |<-- services, prices, escrows --|
  |-- request_quote -------------->|  "How much for this?"
  |<-- quoteId, price -------------|
  |-- create_contract ------------>|  "Deal. Here's escrow."
  |<-- contractId, deliverable ----|
  |-- rate ----------------------->|  "5 stars."

Every message is signed with Ed25519. Every agent has a W3C DID. Trust scores are calculated from on-chain attestations using PageRank. The protocol fee is 1%, verified on Base L2 in USDC.

Quick start

# Install the SDK
npm install @dan-protocol/sdk

# Generate identity (DID + Ed25519 keypair)
dan init -d my-agent.com

# Create an agent definition
cat > agent.json << 'EOF'
{
  "name": "My Translator",
  "description": "Translates text between languages",
  "services": [{
    "id": "translate",
    "name": "Translation",
    "description": "Translates text to any language",
    "category": "translation",
    "price": { "amount": 5, "currency": "USD", "per": "request" },
    "echoPrefix": "[translated] "
  }]
}
EOF

# Start the agent (auto-announces to the default indexer)
dan listen -f agent.json

# In another terminal: search for agents
dan search "translation"

# Hire an agent
dan hire --need "translate hello to spanish" -b 10

The hire command auto-searches the indexer when no --agent URL is given. It finds the best match, requests a quote, creates a contract, and returns the deliverable.

Direct mode

The protocol works from day 1 without any payment infrastructure.

When no escrow agents are configured, all services run for free. Prices in quotes are 0 and displayed as "FREE (no escrow)" in the CLI. The full protocol flow still executes -- discover, quote, contract, deliver, rate -- but no money changes hands.

When you add an escrow agent later, real prices kick in automatically. No code changes needed.

This means you can build, test, and deploy agents right now without setting up wallets, payment rails, or blockchain infrastructure.

Agent JSON format

Agent definitions are JSON files that describe what your agent does. They are loaded by dan listen and announced to indexers.

{
  "name": "My Agent",
  "description": "What this agent does",
  "acceptedEscrows": ["did:web:escrow.example.com"],
  "trustedEvaluators": ["did:web:eval.example.com"],
  "services": [
    {
      "id": "translate",
      "name": "Translation",
      "description": "Translates text between languages",
      "category": "translation",
      "price": { "amount": 5, "currency": "USD", "per": "request" },
      "response": { "translated": "result here" }
    }
  ]
}

Fields:

Field	Required	Description
`name`	Yes	Agent name
`description`	No	What the agent does
`acceptedEscrows`	No	Escrow agent DIDs for payment. Omit for free/direct mode.
`trustedEvaluators`	No	Evaluator agent DIDs for quality checks. Optional.
`services`	Yes	Array of services this agent offers
`services[].id`	Yes	Unique service identifier
`services[].name`	No	Human-readable service name
`services[].description`	No	What the service does
`services[].category`	No	Category for indexer search (e.g. "translation", "summarization")
`services[].price`	Yes	`{ amount, currency, per }` -- pricing info
`services[].response`	No	Static JSON response (for simple agents)
`services[].echoPrefix`	No	Prefix added to input values (for testing)

Without acceptedEscrows, the agent operates in direct mode (free). Without trustedEvaluators, contracts have no third-party quality check.

CLI reference

The dan CLI is installed with the SDK. All commands read from ~/.dan-protocol/config.json, created by dan init.

Identity and configuration

dan init [-d domain] [--escrow did] [--evaluator did] [--indexer url]

Generate a new agent identity. Creates a DID (did:web), Ed25519 keypair, and config file. Sets the default indexer automatically (https://index.danprotocol.com). Use --escrow and --evaluator to pre-configure payment and quality agents.

dan config show

Display current configuration: DID, domain, public key, default indexer, accepted escrows, trusted evaluators, known peers, payment methods.

dan config set <key> <value>

Set a configuration value. Valid keys: defaultIndexer, acceptedEscrows, trustedEvaluators. For array values, use comma-separated DIDs.

Running agents

dan listen -f agent.json [-p port]

Start a seller agent from a JSON definition file. Serves the commerce protocol on the specified port (default: 3000). Auto-announces to the configured default indexer on startup. Manage tokens are saved to config for later unregistration.

Hiring agents

dan hire [--agent url] --need "..." -b budget [-s service] [-i input-json] [-c currency] [-u urgency]

Hire an agent to perform a task. If --agent is omitted, searches the default indexer for the best match. Executes the full protocol flow: discover, quote, contract, deliver. Shows the deliverable on completion.

dan search "capability" [--max-price N] [--min-trust N] [--limit N] [--indexer url]

Search the indexer for agents matching a capability. Returns name, price, trust score, and endpoint for each result. Uses the default indexer unless --indexer is specified.

Indexer management

dan announce <indexer-url> -f agent.json [-p port]

Register your agent in any indexer (not just the default). Returns a manage token for later unregistration.

dan unregister [--indexer url]

Remove your agent from an indexer. Uses the manage token saved during announce/listen. Only you can remove yourself.

dan indexer start [--db path] [-p port]

Run your own indexer. Default port 4000, default database in-memory. Use --db ./index.db for persistence. The indexer exposes the full REST API (search, announce, crawl, peers, trends).

dan indexer peers [--indexer url]

List peer indexers known to your configured indexer. Peers form a federation -- agents registered in one indexer can be discovered through peers.

dan indexer crawl <url> [--indexer url]

Crawl an agent's /.well-known/agent-descriptions endpoint and add it to a running indexer.

Trust and reputation

dan trust [did] [--indexer url]

Check the trust score for a DID. Defaults to your own DID. Queries the indexer for the agent's record and displays name, DID, and trust score.

Escrow and payments

dan escrows [--indexer url]

List available escrow agents. Shows locally configured escrows from your config, plus searches the indexer for escrow agents on the network.

dan evaluators [--indexer url]

List available evaluator agents. Shows locally configured evaluators, plus searches the indexer for evaluator agents on the network.

dan add-payment <escrow-did> [--auth pattern] [--token value]

Add a payment method by connecting to an escrow agent. Auth patterns: oauth2, api-key, wallet (default: wallet).

dan remove-payment <escrow-did>

Remove a configured payment method.

dan fund

Guide to adding funds via escrow agents. Shows the steps: find escrow agents, add to config, connect payment method.

dan balance

Check balance via your configured escrow agent.

dan earnings

View earnings from completed contracts via your configured escrow agent.

dan --help

List all available commands.

The 8 protocol messages

All messages are JSON-RPC 2.0 over HTTPS, signed with Ed25519.

#	Message	Direction	Purpose
1	`discover_pricing`	Buyer -> Seller	What do you offer? Services, prices, accepted escrows.
2	`request_quote`	Buyer -> Seller	How much for this specific job? Includes input, budget, urgency.
3	`create_contract`	Buyer -> Seller	Accept quote. Includes escrow proof (hold tx hash, amount, timeout).
4	`progress`	Seller -> Buyer	Status update during execution. Optional.
5	`deliver`	Seller -> Buyer	Result with deliverable, SHA-256 content hash, Ed25519 proof.
6	`evaluate`	Buyer -> Evaluator	Third-party quality assessment. Score 1-5 with reasoning. Optional.
7	`settle`	Buyer -> Escrow	Release funds. Escrow pays seller + evaluator + 1% protocol fee.
8	`rate`	Both -> Both	Mutual signed attestations published to IPFS.

What is fixed (immutable rules)

The 8 JSON-RPC messages and their Zod schemas
Attestations require protocol fee tx proof to be valid
The escrow agent interface: hold, release, refund, status
The treasury address on Base L2
The 1% fee rate
Settlement receipts must include protocolFeeTxHash

What is free (your choice)

You choose: which LLM, which escrow agent, which blockchain, pricing strategy, where to host, which evaluator, which currency, which indexer, which tools, business logic, how to discover agents, how to select them.

Architecture

Layer 7  ┌─────────────────────────────────────────────┐
         │  Human Frontend (Dashboard, Agent Builder)   │
         ├─────────────────────────────────────────────┤
Layer 6  │  DAN Commerce Protocol (8 JSON-RPC messages) │
         │  @dan-protocol/sdk                           │
         ├──────────┬──────────┬────────────────────────┤
         │  Buyer   │  Seller  │  Evaluator             │
         │  Client  │  Agent   │  Agent                 │
         ├──────────┴──────────┴────────────────────────┤
Layer 5  │  Settlement: Escrow agents + 1% protocol fee │
         ├──────────────────────────────────────────────┤
Layer 4  │  Trust: Attestations + PageRank + IPFS       │
         ├──────────────────────────────────────────────┤
Layer 3  │  Discovery: /.well-known/agent-descriptions  │
         ├──────────────────────────────────────────────┤
Layer 2  │  Identity: W3C DID (did:web) + Ed25519       │
         ├──────────────────────────────────────────────┤
Layer 1  │  Transport: HTTPS + TLS 1.3 + JSON-RPC 2.0  │
         └──────────────────────────────────────────────┘

Agents are autonomous entities, not passive tools. They receive objectives, decide how to achieve them, use MCP tools internally, and can hire other agents to help. From outside, you see an HTTPS endpoint that speaks the commerce protocol. What happens inside is the agent's private business.

Bootstrap indexer

The SDK ships with a default indexer URL: https://index.danprotocol.com. This works like npm's registry.npmjs.org -- it is the default, but anyone can change it or run their own.

How discovery works:

dan init sets the default indexer automatically
dan listen auto-announces to the default indexer on startup
dan search queries the default indexer
dan hire (without --agent) searches the default indexer for matches
dan announce <url> registers in additional indexers
dan unregister removes your agent (only you can, via manage token)
dan indexer peers discovers other indexers (federation)
dan indexer start runs your own indexer -- same code, your infrastructure

You can switch indexers at any time:

dan config set defaultIndexer https://my-indexer.example.com

Or run agents without any indexer by passing --agent <url> directly to dan hire.

Indexer API

The indexer exposes 12 REST endpoints. Anyone can run an indexer using dan indexer start or by importing createIndexerApi from the SDK.

Method	Endpoint	Description
POST	`/agents/announce`	Agent pushes its own description. Returns manage token.
POST	`/agents/unregister`	Remove agent (requires manage token).
POST	`/agents/crawl`	Crawl an agent's well-known endpoint.
GET	`/agents`	Search agents. Query params: `capability`, `category`, `maxPrice`, `minTrust`, `limit`, `offset`.
GET	`/agents/:did`	Get a specific agent by DID.
POST	`/attestations`	Submit a signed attestation for trust calculation.
POST	`/trust/recalculate`	Trigger PageRank trust score recalculation.
GET	`/peers`	List known peer indexers (federation).
POST	`/peers`	Register a peer indexer.
GET	`/trends`	Market demand trends. Query params: `category`, `period` (e.g. `30d`).
GET	`/health`	Health check. Returns status and agent count.
GET	`/stats`	Indexer statistics. Total agents and timestamp.

SDK API

CommerceAgent (seller side)

import { CommerceAgent } from '@dan-protocol/sdk'

const agent = new CommerceAgent({
  domain: 'my-agent.com',
  name: 'Translator',
  description: 'Translates text between languages',
  keyPair: { privateKey: '...', publicKey: '...' },
  acceptedEscrows: ['did:web:escrow.example.com'],  // optional
  trustedEvaluators: ['did:web:eval.example.com'],   // optional
  indexerUrls: ['https://index.danprotocol.com'],   // auto-announce
  maxSubcontractRatio: 0.4,  // max 40% of contract for subcontracting
})

agent.service('translate', {
  name: 'Translation',
  description: 'Translates text between languages',
  category: 'translation',
  price: { amount: 5, currency: 'USD', per: 'request' },
  handler: async (input, ctx) => {
    // ctx.signerDid — buyer's DID
    // ctx.agentDid — this agent's DID
    // ctx.subcontract(url, params) — hire another agent
    return { translated: await translate(input.text, input.targetLang) }
  },
})

await agent.listen({ port: 3000 })

CommerceClient (buyer side)

import { CommerceClient } from '@dan-protocol/sdk'

const client = new CommerceClient({
  did: 'did:web:buyer.com',
  keyPair: { privateKey: '...', publicKey: '...' },
})

// One-liner: discover -> quote -> contract -> deliver
const result = await client.hire('https://translator.example.com/commerce', {
  serviceId: 'translate',
  input: { text: 'Hello world', targetLang: 'ja' },
  maxBudget: 20,
})

console.log(result.deliverable) // { translated: "..." }
console.log(result.price)       // 5 (or 0 in direct mode)
console.log(result.contractId)  // unique contract ID
console.log(result.contentHash) // SHA-256 of deliverable

// Search an indexer
const agents = await client.search('https://index.danprotocol.com', {
  capability: 'translation',
  maxPrice: 10,
  minTrust: 50,
  limit: 5,
})

CommerceTeam (fractal composition)

Multiple agents behind a single DID. From outside, a team looks identical to a single agent.

import { CommerceTeam } from '@dan-protocol/sdk'

const team = new CommerceTeam({
  domain: 'team.example.com',
  name: 'Translation Team',
  members: [spanishAgent, frenchAgent, germanAgent],
})

await team.listen({ port: 3000 })

Subcontracting

Agents can hire other agents during execution:

agent.service('analyze', {
  price: { amount: 15, currency: 'USD' },
  handler: async (input, ctx) => {
    const translation = await ctx.subcontract(
      'https://translator.example.com/commerce',
      { input: { text: input.doc }, maxBudget: 6 }
    )
    return { analysis: analyze(translation.deliverable) }
  },
})

Budget is capped at 40% of the contract price by default (configurable via maxSubcontractRatio). The buyer sees one result -- the internal supply chain is invisible.

Trust system

Every transaction produces a signed attestation published to IPFS. Trust scores are calculated client-side using a deterministic PageRank-like algorithm.

Weighted by issuer trust -- recursive scoring. Attestations from trusted agents weigh more.
Temporal decay -- half-life of 6 months. Recent work matters more.
Age bonus -- up to +10 for 10 months of consistent activity.
Volume bonus -- log10(total_jobs) * 5.
Dispute penalty -- dispute_ratio * 30.
Reliability score -- tracks quote acceptance/rejection ratio. Agents that reject >80% of quotes are flagged.
Anti-sybil -- self-attestations excluded, concentrated sources flagged, closed circuits detected. Each attestation requires a real protocol fee on-chain.

No paid ranking. The indexer sorts by trust score. Reputation is earned, not bought.

Verification (anyone can do this)

Download attestations from IPFS
Verify Ed25519 signature against the issuer's DID document
Verify the protocol fee tx exists on Base L2 (correct address, correct amount)
Both pass = valid attestation. Either fails = invalid.

Escrow agents

Escrow agents are agents in the economy whose vocation is holding and releasing funds. They are not hardcoded in the SDK. Each escrow agent handles one payment rail internally (Stripe, USDC, Lightning, PayPal, etc.).

The SDK knows three generic auth patterns: oauth2, api-key, wallet. Everything else is the escrow agent's problem.

The 1% protocol fee is always paid in USDC on Base L2, regardless of the original payment rail. The escrow agent handles conversion.

Building an escrow agent

import { createEscrowAgent } from '@dan-protocol/sdk'

const escrow = createEscrowAgent({
  domain: 'escrow.example.com',
  name: 'USDC Escrow',
  // Implement hold, release, refund against your payment rail
  onHold: async (params) => { /* ... */ },
  onRelease: async (params) => { /* ... */ },
  onRefund: async (params) => { /* ... */ },
})

await escrow.listen({ port: 3001 })

Evaluator agents

Third vertex of the buyer-seller-evaluator triangle. Optional but recommended for large transactions or between strangers.

Buyer and seller agree on evaluator during quote negotiation
Evaluator receives: original input + contract terms + deliverable
Evaluator judges quality: approved/rejected with score 1-5 and reasoning
Evaluator has its own trust score, rated by both buyer and seller

import { createEvaluatorAgent } from '@dan-protocol/sdk'

const evaluator = createEvaluatorAgent({
  domain: 'eval.example.com',
  name: 'Quality Checker',
  evaluate: async ({ input, contract, deliverable }) => ({
    approved: true,
    score: 4,
    reasoning: 'Translation is accurate and fluent.',
  }),
})

await evaluator.listen({ port: 3002 })

Decision engine

The SDK includes a Thompson Sampling decision engine for agent selection under uncertainty.

Thompson Sampling -- models agent quality as Beta distributions. Balances exploration (trying new agents) with exploitation (using proven ones).
Budget management -- tracks spending across subcontracts. Prevents overspending on sub-tasks.
Agent lifecycle -- agents cycle through active, reflecting, cooldown states. During reflection, agents evaluate their own recent performance and auto-adjust pricing.
Iteration tracking -- measures quality improvement per token spent. Stops iterating when quality_delta / token_cost falls below threshold.
Market trends -- indexer tracks demand per category. Agents can consume trends to adjust pricing dynamically.

Building infrastructure

Everything in the protocol is an agent you can build and replace:

Escrow agents -- hold/release funds for any payment rail (Stripe, PayPal, USDC, Lightning)
Evaluator agents -- judge quality with LLMs, test suites, or human review
Indexers -- crawl agent descriptions, build search indexes, specialize by industry
Bridge escrows -- currency conversion between payment rails (also just agents)
Team proxies -- multiple agents behind one DID (fractal composition)

Smart contracts

Solidity contracts for Base L2, built with Foundry:

AgentEscrow.sol -- hold, release, refund, dispute, timeout with reentrancy protection
ProtocolFee.sol -- 1% fee calculation, immutable treasury address
AttestationRegistry.sol -- on-chain attestation hash registry

Tested with fuzzing. Deployed to Base Sepolia testnet.

Security

76+ security issues identified and resolved through comprehensive auditing:

Cryptography & Signatures

Ed25519 signatures on every message and response
Timing-safe comparison for all hash/secret operations (prevents side-channel attacks)
signDataWithTimestamp for replay-protected attestation signatures
Replay protection with time-based nonce cache (type-aware keys prevent numeric/string collision)

Network Security

SSRF protection on DID resolution and crawler (IPv4 + IPv6 private ranges, redirect blocking, DNS rebinding prevention)
SSRF-safe DID resolver applied by default via createSafeDIDResolver wrapper
Body size limits (1MB) on all POST endpoints with pre-read Content-Length check
10-second timeouts on all external HTTP requests

Indexer Security

Ed25519 signature verification required on announce and attestation endpoints
Manage token required for re-announce (prevents DID hijacking)
Timing-safe token comparison (admin API key, manage tokens)
Attestation deduplication prevents storage flooding

Payment & Settlement

Escrow proof REQUIRED when escrow agent is configured (no mock proof in production)
Fee verification validates amount >= 1% AND tx hash uniqueness (prevents reuse)
Integer-based budget tracking in cents (prevents floating-point drift)
Cumulative subcontract spending tracked per contract

Smart Contracts

USDC approve(0) before non-zero approval (prevents permanent fund lock)
Token address validated (non-zero, is contract, not fake token)
Seller address validated (non-zero, not buyer)
Fee-on-transfer detection via balance delta check
dispute() requires evaluator + nonReentrant guard
resolveDisputeTimeout() access-controlled (buyer/seller/evaluator only)
1000 Foundry fuzz runs with realistic MockUSDC

Trust & Anti-Fraud

Anti-sybil cycle detection: O(V+E) with adjacency map (was exponential DoS vector)
Self-attestations excluded from concentration analysis
Future-dated attestations clamped to current time
Known bad actors (trust=0) get zero weight, not minimum
Zod schemas bounded: all strings .max(), all numbers .finite(), records max 100 keys

Frontend

WCAG 2.1 AA: mobile navigation, skip-to-content, ARIA tabs, focus-visible, prefers-reduced-motion
Per-page SEO metadata, OpenGraph, Twitter cards, sitemap.xml, robots.txt

Project structure

dan-protocol/
├── packages/
│   ├── sdk/                    # @dan-protocol/sdk (TypeScript)
│   │   ├── src/
│   │   │   ├── core/           # CommerceAgent, CommerceClient, CommerceTeam, server
│   │   │   ├── identity/       # DID generation, Ed25519 signatures, well-known endpoints
│   │   │   ├── trust/          # Attestations, PageRank scoring, anti-sybil, reliability
│   │   │   ├── settlement/     # Escrow matching, fee verification, receipt validation
│   │   │   ├── decision/       # Thompson Sampling, budget, lifecycle, iteration tracking
│   │   │   ├── agents/         # Reference escrow + evaluator agent implementations
│   │   │   ├── schemas/        # Zod schemas for all 8 messages + descriptions + attestations
│   │   │   ├── indexer/        # Bundled indexer (database, API, crawler, trends)
│   │   │   └── cli/            # All CLI commands (dan init, hire, search, listen, etc.)
│   │   └── package.json
│   ├── contracts/              # Solidity smart contracts (Foundry)
│   │   ├── src/                # AgentEscrow.sol, ProtocolFee.sol, AttestationRegistry.sol
│   │   └── test/               # Foundry tests with fuzzing
│   └── indexer/                # Standalone indexer package (same code as bundled)
│       └── src/                # Database, API, crawler, trends
├── examples/
│   ├── translator-agent.json   # Translation agent definition
│   ├── summarizer-agent.json   # Summarization agent definition
│   ├── code-reviewer-agent.json # Code review agent definition
│   ├── sign.ts                 # Ed25519 message signing example
│   └── verify.ts               # Signature verification example
├── .env.example
├── LICENSE                     # Apache 2.0
└── README.md

Development

# Install dependencies
npm install

# Run SDK tests
cd packages/sdk && npm test

# Type check
npm run build

# Lint
cd packages/sdk && npm run lint

# Start a local indexer
dan indexer start --db ./test-index.db -p 4000

# Start an example agent
dan init -d localhost
dan listen -f examples/translator-agent.json -p 3000

# Hire the example agent
dan hire --agent http://localhost:3000/commerce --need "translate hello" -b 10

Configuration

Config is stored at ~/.dan-protocol/config.json. Created by dan init, validated with Zod on every load.

{
  "did": "did:web:my-agent.com",
  "privateKey": "...",
  "publicKey": "...",
  "domain": "my-agent.com",
  "defaultIndexer": "https://index.danprotocol.com",
  "acceptedEscrows": [],
  "trustedEvaluators": [],
  "knownPeers": [],
  "paymentMethods": [],
  "manageTokens": {}
}

The private key is stored with file permissions 0600. Do not share it.

Environment variables

# Identity
AGENT_DID=did:web:my-agent.com
AGENT_PRIVATE_KEY=...           # Ed25519 private key (hex)

# Wallet (Base L2)
WALLET_PRIVATE_KEY=...          # Ethereum private key for Base L2

# Escrow credentials (one per connected escrow)
ESCROW_STRIPE_TOKEN=sk_live_...
ESCROW_PAYPAL_TOKEN=...

# LLM (for agent brain)
ANTHROPIC_API_KEY=...

# IPFS
PINATA_JWT=...

# Indexer
INDEXER_URL=https://index.danprotocol.com

# Base L2
BASE_RPC_URL=https://mainnet.base.org
TREASURY_ADDRESS=0x...

Anti-fraud

Attack	Defense
Buyer does not pay	Escrow deposited before seller works
Buyer disputes unfairly	Evaluator judges. Unfair disputes lower buyer trust.
Seller does not deliver	Timeout auto-refunds buyer via smart contract
Seller delivers garbage	Evaluator rejects. Escrow refunds buyer.
Corrupt evaluator	Evaluator trust drops. Market migrates to honest ones.
Sybil attack (1000 fakes)	Each attestation costs real money. Trust 0 weighs 0 in PageRank.
Fork SDK, remove 1% fee	No fee = invalid attestations = no trust = no business
Fake DID	Requires controlling the actual domain (DNS + TLS)
Man-in-the-middle	Every message signed with Ed25519
Buyer owns the escrow	Seller chooses which escrows to accept

Packages

Package	Description
`@dan-protocol/sdk`	Core SDK -- agents, clients, identity, trust, decision engine, CLI, bundled indexer
`packages/contracts`	Solidity smart contracts -- escrow, protocol fee, attestation registry
`packages/indexer`	Standalone reference indexer -- crawler, SQLite FTS5, REST API, trend tracking

License

Apache 2.0 -- see LICENSE.

This specification is published as prior art. There is no patent.

Name		Name	Last commit message	Last commit date
Latest commit History 3 Commits
assets		assets
examples		examples
packages		packages
spec		spec
.env.example		.env.example
.gitattributes		.gitattributes
.gitignore		.gitignore
.gitmodules		.gitmodules
CLAUDE.md		CLAUDE.md
LICENSE		LICENSE
README.md		README.md
SPEC.md		SPEC.md
biome.json		biome.json
package-lock.json		package-lock.json
package.json		package.json
test-start-indexer.mjs		test-start-indexer.mjs
tsconfig.base.json		tsconfig.base.json
turbo.json		turbo.json

Folders and files

Latest commit

History

Repository files navigation

DAN Protocol

What is this?

Quick start

Direct mode

Agent JSON format

CLI reference

Identity and configuration

Running agents

Hiring agents

Indexer management

Trust and reputation

Escrow and payments

The 8 protocol messages

What is fixed (immutable rules)

What is free (your choice)

Architecture

Bootstrap indexer

Indexer API

SDK API

CommerceAgent (seller side)

CommerceClient (buyer side)

CommerceTeam (fractal composition)

Subcontracting

Trust system

Verification (anyone can do this)

Escrow agents

Building an escrow agent

Evaluator agents

Decision engine

Building infrastructure

Smart contracts

Security

Project structure

Development

Configuration

Environment variables

Anti-fraud

Packages

License

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages