OpenAgentNet is built in focused phases, each ending at a fully testable, usable milestone. No phase is started until the prior phase is stable.

Goal: A working agent registry, discovery, messaging, and basic trust. A developer can register an agent, discover other agents, send tasks, and receive results.

Milestone: v0.1.0

• Project scaffold and documentation
• PostgreSQL schema and Alembic migrations (001–004)
• Agent Registry Service (/v1/agents)
• Agent authentication (API key + Ed25519 proof-of-possession + JWT)
• Discovery Engine with capability, tag, trust, region, and p95-latency search plus trust/latency/registration sorting (/v1/discover)
• Redis sorted-set capability index synchronized on agent lifecycle and trust updates, with PostgreSQL fallback; valid empty capability intersections short-circuit to zero candidates while Redis failures fall back to PostgreSQL
• NATS setup with JetStream streams (TASKS, EVENTS)
• Messaging Service (send, receive, ack, cancel)
• Basic trust score (outcome rate + endorsements + age factor + dispute penalty)
• Health check and heartbeat system
• Docker Compose local dev setup
• Example agent: Echo Agent (returns what it receives)
• Example agent: Summarizer Agent
• Dashboard: Agent list, agent detail, trust scores, message inspector, and network graph with authenticated recent message-flow edges plus capability fallback (authenticated /messages history with status filtering and refresh)
• API docs via FastAPI /docs

Timeline estimate: 6–8 weeks (solo) / 3–4 weeks (small team)

Goal: Full trust scoring, endorsements, dispute resolution, and trust-filtered discovery.

Milestone: v0.2.0

• Endorsement system with weight by endorser trust
• Dispute submission and review queue
• Trust score components: endorsement_score, age_factor, dispute_penalty
• Anomaly detection for reputation manipulation
• Trust history timeline per agent
• Dashboard: Trust score breakdown and history timeline (score components and events exposed via GET /v1/trust/{agent_id} and /events)
• min_trust_score filter live in discovery (GET /v1/discover?min_trust_score=)

Status: v0.2.0 shipped — verified by check_phase2.py.

Timeline estimate: 3–4 weeks after Phase 1

Goal: Agents can propose, counter-propose, and formally agree on task parameters before execution.

Milestone: v0.3.0

• Team registration and owner-managed membership (teams and team_members, migration 018_teams.py, authenticated /v1/teams API), with active teams surfaced in discovery responses
• Team broadcasting to all active members via team:<team_id> message destinations and NATS/HTTP fan-out
• Negotiation protocol implementation
• Proposal/counter/accept/decline state machine
• Session tokens for accepted negotiations
• Accepted negotiation terms persisted as immutable task contracts (task_contracts, migration 019_task_contracts.py) and validated contract-backed task creation
• Dashboard: Negotiation activity view (/negotiations)

Status: v0.3.0 shipped — verified by check_phase3.py.

Timeline estimate: 2–3 weeks after Phase 2

Goal: Multi-agent workflow execution. Operators can submit a DAG of tasks that span multiple agents.

Milestone: v0.4.0

• Workflow schema and DAG validation (cycles and orphan dependencies rejected)
• Orchestration engine (dispatch, dependency tracking, retry) — pull-based NATS inbox listener + background dispatch worker
• Workflow status events via NATS (oan.events.workflow.*)
• Workflow failure handling and partial results
• Dashboard: Workflow graph visualizer (React Flow) — operator view via workflow list API
• Example: 3-agent pipeline workflow (fetch → summarize → publish, verified by check_phase4.py)

Status: v0.4.0 shipped — verified by check_phase4.py (16 checks, end-to-end pipeline dispatch).

Timeline estimate: 4–5 weeks after Phase 3

Goal: Agents can publish named context objects and grant read access to specific agents.

Milestone: v0.5.0

• Memory object storage (ephemeral + persistent, TTL expiry)
• ACL enforcement on all memory reads (owner + direct-agent or active-team grants via memory_permissions)
• Streaming memory updates via NATS (oan.events.memory.created|updated|deleted)
• Memory namespace isolation (writes restricted to the caller's own memories), with private/shared_with/team write scopes and owner-authorized team grants (migration 020_team_memory_scope.py)
• Dashboard: Memory browser for operators (/memory)
• Semantic memory search with optional 1536-dimensional pgvector embeddings, cosine ranking, namespace filtering, and pagination (embedding generation remains caller-configured); owner-only PUT updates can replace vectors, and Compose/Kubernetes PostgreSQL images include pgvector for migration readiness

Status: v0.5.0 shipped — verified by check_phase5.py.

Timeline estimate: 3 weeks after Phase 4

Goal: Agents can be listed publicly with pricing, SLAs, and access tiers.

Milestone: v0.6.0

• Marketplace listing schema (pricing, SLA, tiers)
• Search and browse marketplace (/v1/marketplace, filters: capability, min/max price, max p95 latency, min_trust_score, access_tier)
• Access tier management (free, paid, invite-only) with tier details JSONB
• Usage metering and billing hooks (no payment processing in-scope, hooks only) — marketplace_usage table + POST /v1/marketplace/webhooks/billing
• Capability escrow ledger — marketplace_escrows table and authenticated hold/release/dispute/refund endpoints; provider-agnostic state tracking only, with no payment-provider money movement
• Dashboard: Marketplace browse and listing management (/marketplace shows access tier badges and interactive capability, trust, price, and SLA filters)

Status: v0.6.0 shipped — verified by check_phase6.py and escrow-focused tests (migration 017_marketplace_escrow.py).

Timeline estimate: 3–4 weeks after Phase 5

Goal: Support agent networks that span multiple infrastructure providers. Registry federation and cross-region message routing.

Milestone: v1.0.0

• Authenticated registry federation protocol with signed agent-id validation and reconciliation sync
• NATS cluster and leaf-node configuration for multi-region deployments
• Cross-region discovery with region and federation provenance filters
• Operator-controlled agent migration between regions and registries
• Kubernetes deployment manifests for PostgreSQL, Redis, clustered NATS, backend replicas, probes, migrations, backend HPA (3–20 replicas), and PodDisruptionBudget

Status: v1.0.0 implemented — deployment and control-plane primitives are ready for regional rollout.

Timeline estimate: 6–8 weeks after Phase 6

Goal: Complete the distributed execution backlog with replayable streams, intelligent routing, auditable agent evolution, extensible trust scoring, privacy-preserving outcome proofs, and first-party developer tools.

Milestone: v1.1.0

• Agent-to-agent streaming with ordered, idempotent task chunks and SSE replay
• Capability-aware deterministic routing with optional OpenAI-compatible LLM ranking
• Immutable agent version snapshots and capability diff API
• Pluggable trust-score component registry with operator visibility and persisted breakdowns
• Privacy-preserving binary outcome proofs using a non-interactive Schnorr OR proof transcript
• Python client SDK for registry, discovery, tasks, routing, streaming, versioning, and proofs
• TypeScript client SDK with browser/Node fetch support and typed SSE streaming
• oan CLI for discovery, routing, task operations, agent history, and proof verification

Status: v1.1.0 implemented — all previously unscheduled backlog items have a documented implementation and focused tests.

The hardening toolkit now includes backend/scripts/load_test.py, an asynchronous HTTP harness with configurable request count, concurrency, timeout, authentication, status aggregation, p50/p95/p99 latency reporting, and optional threshold gates for latency, throughput, and success rate. Operators can use it to validate the documented 500-concurrent-agent and 10,000-messages-per-minute targets in an environment with the required services; this repository does not claim those production targets without an executed deployment benchmark.

No unscheduled backlog items remain from the original project feature inventory.

To keep scope focused:

• Execution runtime: OpenAgentNet does not run agent code. Agents execute on their own infrastructure.
• Payment processing: Marketplace will have billing hooks, not a payment processor. Operators integrate their own.
• LLM APIs: No LLM is bundled. Agents choose their own models.
• Agent IDE: The dashboard is a monitoring/management tool, not an agent builder.