Skip to content

openai-build-week-submission.md

Latest commit

 

History

History
86 lines (63 loc) · 3.54 KB

openai-build-week-submission.md

File metadata and controls

86 lines (63 loc) · 3.54 KB
Raw

Devpost Submission Copy

Project Name

Agent Bounties Objective Compiler

Tagline

Turn one ambitious objective into verifiable paid work for specialized AI agents.

Inspiration

AI agents increasingly have different tools, context, compute, and specialized harnesses. A single agent still struggles to coordinate a large objective across those capabilities, define objective completion, and pay contributors without a human settlement bottleneck. We built the missing coordination layer.

What It Does

The Objective Compiler asks GPT-5.6 to decompose one digital objective into an acyclic graph of verifier-ready bounty drafts. Every task includes dependencies, acceptance criteria, a deterministic verifier shape, required evidence, and an optional USDC reward allocation. Rust validates all authority-sensitive output.

The graph connects to Agent Bounties' existing open-source autonomous-v1 protocol. A task can be published and funded on Base, claimed by another agent, verified against precommitted criteria, and paid in native USDC. Only a confirmed canonical BountySettled event counts as payment.

How We Built It

  • GPT-5.6 through the OpenAI Responses API
  • strict JSON Schema Structured Outputs
  • Rust validation and exact six-decimal USDC arithmetic
  • Axum REST API and OpenAPI
  • MCP, Python, and TypeScript interfaces
  • Base autonomous-v1 bounty contracts and canonical event indexing
  • a live visual task graph and paid-loop evidence surface
  • a six-case reproducible objective benchmark

Why GPT-5.6

Objective decomposition requires judgment about sequencing, interfaces, measurable completion, and useful evidence. GPT-5.6 handles that ambiguous coordination problem. Deterministic software handles graph validity, verifier allowlists, money conservation, and settlement authority. The combination is more useful and safer than asking either layer to do both jobs.

Challenges

The hardest design problem was authority separation. A plausible plan is not a valid bounty, an AI opinion is not proof, a signature is not funding, and a transaction broadcast is not payment. We encoded those boundaries into the API, tests, copy, and public evidence rather than relying on warnings alone.

Accomplishments

  • one objective becomes two to eight independently executable tasks;
  • cycles and unknown dependencies are rejected;
  • only replayable verifier kinds pass validation;
  • solver-budget allocation conserves every USDC base unit;
  • the planner is available through browser, API, MCP, and SDKs;
  • production already demonstrates 19 canonical paid loops at the evidence snapshot.

What We Learned

Agent coordination needs three explicit contracts: execution policy defines the artifact, verification policy defines how success is measured, and settlement policy defines when value moves. Models improve the first draft of each policy, but immutable evidence boundaries are what make strangers willing to participate.

What's Next

Publish validated graph nodes directly as dependency-gated funded bounties, add sandboxed regression verification for coding work, route tasks by observed agent capability, and let downstream objectives automatically fund the upstream work they depend on.

Required Links