How Humans and Agents Built Escroue
A 5-day collaboration between a human architect and an agent, building a trustless agent-to-agent marketplace with 8 protocol integrations across 2 chains.
The Collaboration Model
Human direction + agent execution + iterative review = rapid, high-quality output.
Architecture decisions, technology choices, hackathon strategy, and integration priorities. The human defines what to build and why — never how.
The agent handles all implementation: contract development, testing, deployment, frontend, integrations, documentation. Structured by the Superpowers skills framework.
Human reviews output, provides feedback, and redirects. The agent iterates based on direction — not guessing. Each cycle compresses scope and improves quality.
Build Timeline
Day-by-day breakdown of what the human directed and what the agent built.
Key Architecture Decisions
Every major technical decision and who made it.
Foundry's Rust-based toolchain is faster for testing and the agent can write fuzz tests natively. 40 tests run in under 2 seconds.
Type-safe, tree-shakeable, and better DX for the agent. Contract interactions are more explicit and less error-prone.
Latest framework for the frontend. Server components where possible, client components for interactive elements. Deployed as standalone on Render.
Targeting both Synthesis and Celo hackathons doubled our submission surface. Same contracts, identical addresses via CREATE2 — minimal extra work for maximum coverage.
Each hackathon track gets a dedicated frontend page with deep technical content. Judges can see exactly how each protocol is integrated without digging through code.
On-chain agent identity standard that works across chains. Buyer #2194/#225 and Seller #2195/#226 are verifiable on both Base and Celo.
By the Numbers
What 5 days of human-agent collaboration produced.
What We Learned
Insights from building a production-quality project through human-agent collaboration.
The agent integrated 8 different protocols in 5 days — something that would take a solo developer weeks. But every integration decision (which protocols, what priority, how deep) came from the human. The agent's strength is execution speed and consistency; the human's strength is knowing what matters.
Installing the Superpowers framework on Day 1 paid massive dividends. Instead of ad-hoc development, the agent followed TDD cycles, wrote verification checks, and used structured debugging. The framework turned an LLM into a disciplined engineer.
Deploying to Celo Sepolia after Base Sepolia was trivial — the agent reused the same deployment scripts with different RPC URLs. CREATE2 gave us identical addresses on both chains. Multi-chain deployment is an agent superpower because it's mechanical, not creative.
Every integration got its own frontend page, README section, and on-chain verification. The agent doesn't get tired of writing docs. This build story itself was authored as part of the workflow — not as an afterthought.
Human-agent collaboration isn't "human writes spec, agent builds it." It's a continuous loop: human sets direction → agent executes → human reviews → agent iterates. The README alone went through 3 revision cycles. The quality comes from the loop, not any single step.
Explore the Integrations
Each protocol integration has its own dedicated page.
Built for The Synthesis Hackathon — Best Build Story (OpenServ Track)