Agent Agora

An auction-powered launchpad where specialized AI agents bid, collaborate, and recover without duplicating work.

Comment

Inspiration

Most multi-agent systems either send every task to every agent or depend on another model to act as an opaque coordinator. Both approaches can be expensive, difficult to audit, and fragile when execution is interrupted.

We wanted to explore a different question:

What if AI agents had to propose a concrete plan and cost estimate before they were trusted with the work?

That idea became Agent Agora: a durable agent marketplace built on Volcengine Ark and Codex. Specialized agents compete when competition adds value, while straightforward requests can still take a fast, single-agent path.

What It Does

Agent Agora supports three routing modes:

  • Direct sends a request to one selected agent without collecting bids.
  • Auction collects isolated, structured bids from every eligible agent.
  • Auto asks one primary agent for a candidate answer and escalates to an auction only when confidence, budget, or policy checks are not satisfied.

Each bid contains a proposed execution plan, assignments, risks, assumptions, confidence, and estimated output usage. Valid bids are ranked deterministically using integer basis-point arithmetic:

The winning plan can use:

  • A single specialist
  • A sequential team, where later agents see earlier contributions
  • A parallel team for independent work that can be completed concurrently

The interface clearly separates bidding from execution, displays the award and its score components, compares projected and actual token usage, and keeps losing bids available as expandable evidence without leaking them into the conversation or other agents' prompts.

Users can also mark high-risk requests, inspect fallback decisions, and rate an award as accepted or rejected for future confidence calibration.

How We Built It

We extended Volc Agent Launchpad into a durable multi-agent coordination platform:

  • A React and TypeScript interface provides agent configuration, session routing, live progress, award explanations, token evidence, and feedback.
  • A Fastify control plane validates policies and structured model output with Zod.
  • Codex CLI runs agents against the Volcengine Ark Responses API.
  • Purpose-aware execution waves use bounded concurrency for bidding and parallel plans.
  • Every bid, award, attempt, usage record, and published response is stored in a versioned evidence ledger.
  • Fresh execution threads isolate bidders from unrelated conversation history.
  • Atomic, version-checked mutations prevent competing loops or restarts from creating duplicate awards.
  • Docker-based local execution gives each turn a disposable runtime, while Terraform provides a deployment path to Volcengine ECS.

The deterministic ranking engine uses stable tie-breaking and integer arithmetic, so identical durable evidence always produces the same result.

Challenges We Faced

The hardest problem was not collecting bids—it was making the auction trustworthy under failure.

A server could stop after all bids were committed but before an award was created, or after an award was stored but before execution began. Initially, one of these boundaries could leave a session looking healthy while its awarded work was permanently stranded.

We redesigned restart reconciliation so the system derives its next action from committed artifacts. Interrupted auction rounds remain resumable, cancelled zero-attempt execution turns can be scheduled again, and only committed assignments count as completed. Recovery therefore preserves settled bids and committed awards without repeating finished work.

Other challenges included:

  • Preventing model output from changing policies, budgets, or participants
  • Keeping losing bids out of other agents' context
  • Allowing partial bidder failure without weakening execution guarantees
  • Separating bidding cost from projected and actual execution usage
  • Supporting parallel work while respecting concurrency limits and agent reservations
  • Preserving compatibility with older stored sessions

What We Learned

We learned that reliable multi-agent systems need more than good prompts. The backend must own scheduling, validation, budgets, leases, retries, and state transitions.

We also learned that model confidence should be treated as evidence—not truth. Agent Agora labels it as self-reported, calibrates it using feedback and execution history, and explains that an award is the highest-ranked valid bid under a particular scoring version, not proof that an agent is objectively best.

Most importantly, we found that durable artifacts make recovery simpler and more predictable. If every decision can be re-derived from committed bids, awards, and turns, a restart becomes another state transition instead of a special-case disaster.

The completed branch passes 760 automated tests and has been exercised through direct routing, ten-agent auctions, automatic escalation, sequential and parallel team execution, partial bidder failure, stop-and-resume, and exact-boundary restart recovery.

TECH STACK

  • TypeScript
  • React
  • React DOM
  • Node.js
  • Fastify
  • Vite
  • Vitest
  • Zod
  • Codex CLI
  • Volcengine Ark
  • Responses API
  • Docker
  • Docker Compose
  • Terraform
  • Volcengine ECS
  • REST API
  • JSON
  • Multi-Agent Systems
  • LLM Orchestration
  • Concurrent Processing
  • Durable Workflows
  • Evidence Ledgers

TRY IT OUT

No public hosted deployment is currently configured. After following the quick-start instructions, the application is available locally at http://localhost:3001.

Built With

Share this project:

Updates