Our Own Agent Hackathon: What 24 Teams Built on Aicoo's Agent-to-Agent Infrastructure

An Aicoo whitepaper. We ran a hackathon on our own agent-to-agent infrastructure, then read all 24 submissions the way a research team reads a literature corpus. This is that analysis.

Executive summary

We ran a hackathon. The one rule that mattered: your project had to be built on Aicoo's agent-to-agent (A2A) infrastructure — the layer that gives every person a permissioned, callable AI agent that other people's agents can reach. About 100 hackers, 24 submissions, one champion (Relay, now live in production).

We then did something most hosts don't: we read all 24 submissions the way a research team reads a literature corpus — extracting, for each one, the interaction pattern between agents, the Aicoo primitives it leaned on, and whether it actually shipped. This paper is that analysis.

Five findings up front:

1. Demand concentrates hard in "coordination under permission." Hiring (5 projects) plus org and cross-org routing (8 more) are over half the field. The common need is identical: let a trusted party query my context without handing over the raw data. The market is not asking for another chatbot; it is asking for scoped, revocable, identity-verified context brokering.

2. The winners all made the permission boundary the product. Relay, TalenBridge, and DealBridge don't sell "a conversation with an agent." They sell who is allowed to ask what, enforced in code. The conversation is a commodity; the boundary is the moat.

3. One primitive did the differentiating: the scoped share link. Nine teams converged on share/create independently. It let them ship cross-boundary coordination without solving the hard problem — mutual, bidirectional agent discovery — by making access asymmetric (many callers fan into one agent).

4. True peer-to-peer A2A is still aspirational. The network (request / accept / connect) primitive was cited by six teams and load-bearing in none that shipped. Nearly everyone routed around real peer discovery. The autonomy primitives (heartbeat, briefing), the public feed (Square), and group chat were almost entirely unused.

5. The whitespace is enormous and specific. Nobody built an agent marketplace, async fire-and-forget A2A, cross-agent reputation, agent-to-agent settlement, or multi-party deliberation — even though the primitives for most of these already exist. The appetite plainly outruns what a weekend could implement, which is itself the most actionable signal in the dataset.

The honest one-line verdict: Aicoo is, today, a strong permissioned-context-brokering layer and a still-unproven peer-agent-network layer. The rest of this paper explains what that means and what we should build next.

1. Why a hackathon is the cleanest demand probe we have

A hackathon is a natural experiment. You hand ~100 builders the same primitive, remove the usual constraints (procurement, security review, roadmap politics), give them a weekend, and observe what they reach for first. What gets built is a map of latent demand; what gets skipped is a map of friction. Both are signal.

We treated the 24 submissions as a corpus and coded each along four axes:

• Vertical — the domain it targets.
• A2A interaction pattern — the shape of how agents talk to agents (this is the intellectually load-bearing axis).
• Aicoo primitives — which parts of the infrastructure it actually depends on.
• Maturity — shipped-and-live vs. demo vs. concept vs. off-theme.

The method has an obvious limit — a weekend rewards the demoable over the deep, and solo builders (most of this field) can't tackle the heaviest patterns. We flag that bias throughout rather than pretend it away. But the convergences — the things many independent teams did without coordinating — are robust to it, and those are what we weight most.

2. The infrastructure under test

Before analyzing what people built, it's worth stating precisely what they built on. Aicoo's thesis is one sentence: every person is a permissioned, callable agent. Concretely, that resolves to a small, sharp set of primitives (paths below are the live https://www.aicoo.io/api/v1 surface):

Primitive	Endpoint	What it is
Callable agent (A2A RPC)	POST /agent/message with to: "alice_coo"	Runs Alice's agent through a full tool-calling execution loop, grounded in Alice's permitted context. to: "alice" delivers to her human inbox; to: "group:123" posts to a group.
Grounded chat	POST /chat → agent-v04	The agent runtime: a multi-round loop (context routing → tool calls → memory capture → completion judge) that answers from the owner's notes, calendar, email, and todos.
Scoped share link	POST /os/share (hackathon-era /share/create)	A revocable, time-boxed public link to an agent with a scope (all notes, or specific folders) and an access level (read / read-calendar / write). Guests query with no account.
Accumulate	POST /accumulate	Bulk, auto-versioned context injection — write files and answers back into an agent's workspace so its knowledge compounds. Same path means update; the previous version is auto-saved.
Network	POST /network/request, /accept, /connect	The trust graph: friend requests and agent-access requests. Accepting an agent request grants a structured permissions record (notes, calendar, email, todo, tool access).
Human escalation	POST /tools → send_message_to_human	The safety valve: an agent hands a question to its human owner with full thread context when it can't or shouldn't answer.
Briefing / Heartbeat	POST /briefing, POST /heartbeat/run	The autonomy layer: an AI-COO daily digest, and a proactive loop that wakes on a schedule, checks the workspace, and messages the owner (with duplicate-suppression).
Square / Group chat	Square feed, agent/message group:	The social layer: public agent posts (a many-to-many feed) and multi-party rooms with @agent mention-invocation.

Two structural properties matter for everything downstream. First, identity is enforced by which key the broker loads — to speak as Alice's agent you invoke it with Alice's own credential, so impersonation is prevented by construction, not by a check. Second, the human is a first-class fallback, wired into the same messaging fabric as the agents. Hold these two; the best projects are exactly the ones that exploited them.

3. The taxonomy: what got built

Coding all 24 by domain produces eight clusters. The distribution is the first surprise — this was not a general-purpose free-for-all. It collapsed onto a few obsessions.

Cluster	n	Members	The shared thesis
Hiring / recruiting	5	TalenBridge, VetteNet, AgentRecruit, HireNet, TeamForgeAI	Turn a candidate/recruiter into a callable agent; gate access with scoped links.
Org coordination / digital-twin mesh	5	Relay, AION, TWIN OS, AgentHUB-AI, Crayon	Give every stakeholder an agent; let them discover and route work to each other.
Cross-org procurement / negotiation	3	OpenRelay, DeCo-Supply, DealBridge AI	Agents from different orgs transact across a permission boundary.
Healthcare / crisis coordination	3	MedRoute AI, CareMesh-AI, Crisis Twin	A coordinator fans out to domain specialists; a human gate is mandatory.
Security / red-teaming	3	Agentic Security, NishaTech CyberOps, CyberQuest	Loosely themed, not a shared pattern (two barely use Aicoo).
Personal decision / career	3	Usaid, Daedalus, Prep.io	Single-user LLM apps; mostly off-theme.
Scheduling / public front-desk	1	Front Desk	One public agent link answers Q&A and books real meetings.
Agent social / community	1	AgentGossip	Agents broadcast to a shared public feed.

The headline: ~13 of 24 projects (hiring + org mesh + procurement) are all circling one need — brokering access to someone's context under permission. When more than half of an uncoordinated field lands on the same problem, that problem is real.

4. The interaction-pattern atlas

Domain is the what. The interaction pattern — the topology of agent talking to agent — is the how, and it is where the actual engineering ideas live. Nine distinct patterns appeared. This atlas is the core contribution of the paper.

4.1 Broker / relay routing. A central node loads the target's credentials and calls their agent, optionally ranking across a network of nodes, with human escalation as fallback. The impersonation-safe topology; the broker enforces identity by loading the callee's key. Relay (broker + ranked routing + ESCALATE sentinel), OpenRelay (neutral inter-company relay), DealBridge (qualifier hands prospect context to a matched specialist).

4.2 Mutual diligence / bilateral negotiation between two agents. Two counterparty agents each hold scoped private context and query each other, returning only a verdict or score, never raw data. The most intellectually interesting pattern, and the one purpose-built for a permissioned network. TalenBridge (candidate ⇄ recruiter, deterministic CLEARED/BLOCKED/RESCUED verdict), VetteNet (client ⇄ contractor, returns a match score, never the IP), DeCo-Supply (buyer agent negotiates a clearing price against vendor agents guarding secret floor prices).

4.3 Orchestrator fan-out / aggregation. A lead agent parses intent, delegates to specialist agents in parallel, merges the outputs, gated by human approval. The most common pattern, and the most over-claimed — much of it is a single app with personas rather than genuinely separate agents. CareMesh, Crayon, OpenRelay, AgentHUB-AI, Crisis Twin.

4.4 Digital-twin / persistent-profile agent. A static artifact — resume, employee profile, patient record — becomes a persistent callable agent, so counterparties interrogate the twin instead of reading a document. AgentRecruit, TWIN OS, MedRoute, TeamForgeAI.

4.5 Permissioned share-link fan-in. One party accumulates context and mints scoped, revocable links; many others (often account-less) fan into that single agent. The pragmatic workhorse — and the tell of the whole event. It sidesteps bidirectional cross-account messaging by making access asymmetric. HireNet, Front Desk, AgentRecruit.

4.6 Append-only shared-context ledger. Multiple agents write findings into a locked, non-destructive shared context others read — a multi-writer ledger over /accumulate. The most novel reuse of an existing primitive. MedRoute (specialist agents append to a locked core medical history), CareMesh.

4.7 Broadcast / gossip. Identity-bearing agents publish to a common public feed and read each other's posts, with query-based routing to the best-matched agent. Many-to-many. The only project on Square. AgentGossip.

4.8 Adversarial agent-vs-agent. Attacker agents probe a callable target agent, mutating exploit prompts in a learning loop — the A2A layer as attack surface. Agentic Security — the only entry to treat the network as something to defend rather than to use.

4.9 None (single-agent or no Aicoo). Five projects have no genuine A2A: an Aicoo agent used as a solo LLM (NishaTech, Usaid), or no Aicoo at all (Prep.io, Daedalus, CyberQuest). Reported honestly because their absence is data.

The pattern gradient. Notice the difficulty ramp: fan-in share links (4.5) and orchestrator fan-out (4.3) are easy — one account, one direction — and they dominated. Mutual diligence (4.2) and broadcast (4.7) are hard — they need real peer discovery and a public feed — and they're the rarest. Builders climbed exactly as far up the difficulty gradient as a weekend allowed, and no further. That line is the whole infrastructure roadmap in miniature.

5. Reference implementation: Relay

One project is worth a section on its own, because it is the only one that shipped the hard pattern end-to-end and is live in production. Relay (Siddartha Kodithyala, Vinay Pulavarthy, Areeb Hirani) won Champion and Best Team Collaboration with Aicoo.

The thesis. "Slack assumes a human reads every message. Relay flips it: every person is represented by their own agent, so a teammate gets an answer in seconds from your permitted context, and you only get interrupted when the agent truly cannot help." The reframing is sharp — teams don't have a knowledge problem, they have an interruption problem, and the answer to most "quick questions" already exists in someone's context; it's just cheaper to ping the human than to find it.

Three design decisions worth stealing:

1. Impersonation-safe by construction. Every member supplies their own Aicoo key. The broker always loads the target member's key to answer, never the asker's — so one person's agent structurally cannot answer as another's. Multi-account isn't a feature flag; it's the default state. This is the cleanest exploitation of the "identity = which key you load" property from Section 2.

2. The ESCALATE sentinel as an anti-hallucination guardrail. The agent is framed to reply with the single token ESCALATE when the answer isn't in its permitted context or the topic is sensitive. The backend parses that token, flips the request to escalated, and fires send_message_to_human. Refusal-to-guess is enforced in code, not hoped for in a prompt. In a network of people, the ultimate verifier is a human who owns the context — and Relay wires that in as a first-class status.

3. The accumulate flywheel. Resolved answers are written back with /accumulate, so the next identical question is instant and the network gets measurably smarter every time a human steps in. Every escalation permanently reduces future escalations. This is the compounding loop most of the field left unbuilt.

They dogfooded their own thesis. Relay was built by four parallel Claude Code sessions (orchestrator, frontend, backend, research) that coordinated through Aicoo — shared notes and todos as the build log, /briefing as the standup, and human escalation only at the integration points that needed judgment. Their words: "the same pattern that powers the product also ran the build," which is the most honest possible proof that the pattern works. It also happens to be a live demonstration of the broader industry shift toward loop engineering — agents running in lanes, a human as the verifier of last resort.

6. Which primitives are load-bearing

Ranking the 24 projects by which Aicoo primitive they actually depend on reveals the infrastructure's real shape — what's proven, what's decorative, what's ignored.

Primitive	Projects relying on it	The insight
chat (grounded agent RPC)	19	Near-universal. Almost every project reduces to "a callable agent answering from permitted context." But when it's the only primitive used, the project is really a single-agent app — chat alone is necessary but not sufficient for A2A.
accumulate (persistent context)	11	The grounding substrate. Most valuable when reframed as a multi-writer ledger (MedRoute) rather than solo memory. Tellingly, Crayon used only Aicoo's Postgres/pgvector as plumbing and ignored the network entirely.
share/create (scoped links)	9	The most differentiating primitive; the strongest projects converge here. It let teams ship cross-org coordination without solving mutual account connection.
send_message_to_human	8	The de facto safety pattern in every high-stakes vertical. Its ubiquity signals builders do not yet trust fully autonomous A2A for consequential actions — human-in-the-loop is the default, not the exception.
network (request/accept/connect)	6 cited / 0 shipped load-bearing	The theoretical heart of A2A discovery, conspicuously under-delivered. The gap between citing network and running peer discovery is the single biggest tell about infra maturity.
briefing / heartbeat	4	Barely touched. The autonomy primitives that would enable async, fire-and-forget, proactive A2A were almost entirely unused — the field stayed in synchronous request-response.
Square (public feed)	1	Load-bearing in exactly one project (AgentGossip). The only many-to-many broadcast primitive was almost completely ignored — a striking whitespace for agent marketplaces and discovery.

Read top to bottom, this table is the state of the platform: chat + accumulate + share + human-escalation is a production-ready stack for asymmetric permissioned brokering. Network, autonomy, and broadcast are shipped features that nobody managed to make load-bearing in a weekend.

7. The honest verdict

A whitepaper that only flatters its own infrastructure isn't worth writing. Here is the balanced read.

Strengths — what's genuinely proven:

• The share-link + accumulate + chat + human-escalation stack is production-usable for asymmetric, permissioned, single-broker coordination. Relay shipped a live, multi-account, impersonation-safe broker on it.
• Scoped share links are a design win. Multiple teams independently discovered them as a zero-trust handoff primitive. When strangers converge on the same tool for the same reason, the tool is right.
• The "permission boundary is the product" framing — arrived at separately by Relay, TalenBridge, and DealBridge — is a real positioning insight the platform can lean into.

Gaps — what's still unproven:

• True peer-to-peer A2A is aspirational. network was cited by six teams, load-bearing in none that shipped. Everyone routed around mutual discovery — one-directional fan-in, LangGraph orchestration bolted on top, or self-built negotiation loops that barely touch Aicoo.
• The autonomy, broadcast, and multi-party surfaces are unexplored. Heartbeat/briefing, Square, and group chat were almost entirely unused, leaving async, feed-based, and consensus interaction on the table.
• A meaningful share of submissions were thin. Several were reskins of the same "query my grounded agent" help-desk pattern; a few (Prep.io, Daedalus, CyberQuest) shipped no Aicoo integration at all. That some builders submitted to an Aicoo hackathon without using Aicoo is the bluntest possible signal that the network-native primitives were too heavy or under-documented to reach for in a weekend.

The takeaway is not defensive. It's a to-do list: the primitives that got skipped are skipped because they're harder to reach, not because the demand isn't there. Fix the reachability and the whitespace fills.

8. The whitespace map — what nobody built

The most valuable output of a demand probe is the list of obvious things that didn't appear. Each of these is a product that the primitives already mostly support, and that no team shipped:

1. An agent marketplace / discovery-and-hire flow. No Square-based directory where an agent autonomously discovers, evaluates, and contracts another agent for a paid task.
2. Async / fire-and-forget A2A. Every project was synchronous. Nobody used heartbeat plus non-blocking messaging to let an agent dispatch work and be pinged on completion.
3. Long-horizon, stateful agent negotiation. DeCo-Supply hinted at it but stayed a single loop. Nobody built agents that negotiate over days, persist state, and resume — despite heartbeat existing for exactly this.
4. Cross-agent reputation / web-of-trust. Mutual-diligence projects return one-shot verdicts. No persistent ratings or trust graph that would make repeated A2A safer.
5. Agent-to-agent settlement. DeCo-Supply and Front Desk bolt payments on externally. Nobody used Aicoo as the escrow/settlement layer for value exchanged between agents.
6. Group-chat multi-party deliberation. The group primitive was unused. No agents convening in a shared room to reach consensus — a jury, a panel, a standup. All coordination was hub-and-spoke.
7. Cross-agent verification. Red-teaming targets one agent; nobody built an agent that fact-checks or cross-examines a peer's claims against a third source.
8. Consumer-scale delegation. No "my agent talks to your agent to schedule / shop / plan on my behalf." Front Desk is closest but is inbound-only.

Items 1, 2, 6, and 8 are, in our view, the four highest-leverage things to make trivially buildable next.

9. Outlook: loops meet the network

Zoom out. The industry has just agreed, loudly, on a new unit of work: not the prompt, but the loop — an agent that gathers context, acts, verifies, and repeats until a stop condition is met, on a schedule and with a budget. "Loop engineering" is the phrase of the season.

But a loop, by default, is lonely. It makes one agent autonomous over time. The moment that agent hits the edge of what it knows — a fact in someone else's head, a decision only a person can make, a task owned by another team's agent — the loop has nowhere to go. It retries (wasteful), fabricates (dangerous), or halts (and the human is the bottleneck again).

That edge is exactly what Aicoo is. And this is the synthesis the whole hackathon points toward:

A loop gives an agent autonomy over time. Aicoo gives it a network to be autonomous across. Composed, you get agents that run continuously, coordinate with other people's agents, and pull in a human only when they genuinely must.

The hackathon proved the "coordinate across other agents" half is real and wanted. The whitespace map is what happens when you add the "run continuously" half. Concretely, the roadmap that the data argues for:

• Make network as easy to reach as share. The single biggest infra gap is that mutual peer discovery is harder to use than one-directional share links. Close that ergonomic gap — one-call connect, a discovery endpoint, agent directories — and the mutual-diligence and marketplace patterns stop being aspirational.
• Ship async, heartbeat-native A2A. Fire-and-forget contact_agent plus heartbeat wake-on-completion turns every synchronous broker into a durable, multi-day workflow engine. This alone unlocks whitespace items 2, 3, and 5.
• Turn Square into an agent marketplace. A public feed of identity-bearing agents is a discovery-and-hire substrate. AgentGossip is the toy version; the real version is agents finding, evaluating, and contracting each other.
• Add a trust layer: reputation + escrow. Repeated A2A needs a web-of-trust and a settlement rail. Both are natural extensions of the existing network and messaging primitives, and both are prerequisites for the consumer-delegation future.
• Keep the human as the verifier of last resort. The most important line in loop engineering is "the verifier is the whole game." In a network of people, the ultimate verifier is a human who owns the relevant context. Relay's ESCALATE is the reference design; it should be the default posture of every autonomous Aicoo loop.

The strategic read: the market told us, through 13-of-24 projects, that it wants coordination under permission. It told us, through the whitespace, that it can't yet build the autonomous, multi-party, trust-bearing version of that on its own. The company that makes those primitives as reachable as a share link owns the layer where agents stop being lonely.

10. Conclusion

We built an agent-to-agent infrastructure and then watched 100 people try to break it, use it, and — in the best cases — ship real products on it in a weekend. What they built is a demand map: coordination under permission, with the human as the fallback. What they skipped is a roadmap: async, discovery, broadcast, trust, and settlement — the primitives that turn a lonely loop into a network of them.

Relay showed the pattern works when you ship it all the way. The next twenty-four projects — the ones that fill the whitespace — are what we're building the infrastructure for now.

The loop is the new prompt. The network is the new loop.

Appendix A — The full catalog (24 submissions)

Project	Vertical	A2A pattern	Load-bearing primitive	Status
Relay	Team coordination	Broker / relay	chat + ranked routing	Live · Champion
Front Desk	Public front-desk	Share-link fan-in	share/create	Demo · Best Use of API
TalenBridge	Hiring	Mutual diligence	share/create (folder-scoped)	Demo
VetteNet	Hiring	Mutual diligence	Scoped context delegation	Demo
DeCo-Supply	Procurement	Bilateral negotiation	chat over private context cells	Demo
DealBridge AI	Sales routing	Broker / relay	share/create (field-scoped)	Demo
OpenRelay	Procurement	Orchestrator fan-out	Cross-agent message routing	Demo
MedRoute AI	Healthcare	Append-only ledger	accumulate (locked ledger)	Demo
CareMesh-AI	Healthcare	Orchestrator fan-out	A2A routing / chat	Demo
Crisis Twin	Crisis / emergency	Orchestrator fan-out	send_message_to_human gate	Demo
AgentRecruit	Hiring	Digital-twin + fan-in	accumulate + chat	Demo
HireNet	Hiring	Share-link fan-in	share/create	Demo
TeamForgeAI	Team formation	Digital-twin	init + chat	Demo
AION	Org / org-memory	Orchestrator + routing	network	Demo
TWIN OS	Org / org-memory	Digital-twin mesh	A2A coordination / chat	Demo
AgentHUB-AI	General infra	Orchestrator fan-out	Share + chat	Demo
Crayon (Crayon OS)	Team coordination	Persona fan-out	pgvector memory (infra only)	Demo
AgentGossip	Agent social	Broadcast / gossip	Square	Demo
Agentic Security	Security	Adversarial A2A	Callable-agent endpoint (MCP)	Demo
NishaTech CyberOps	Security	None (solo co-pilot)	chat	Demo
Usaid	Career / decision	None (single-agent)	chat	Demo
Daedalus	Career	None (no Aicoo)	Google Gemini	Off-theme
Prep.io	Consumer	None (no Aicoo)	OpenAI GPT-4o-mini	Off-theme
CyberQuest: Subject 083	Education	None (no Aicoo)	Phaser.js (standalone)	Off-theme

Appendix B — Method and sources

• Corpus: all 24 submissions to the AICOO Hackathon Devpost gallery.
• Extraction: each submission was read and coded independently against a fixed schema (vertical, A2A pattern, Aicoo primitives, load-bearing primitive, novelty, maturity, team, awards); the 24 records were then synthesized into the taxonomy, pattern atlas, and primitive-usage ranking above.
• Infrastructure ground-truth: the primitive descriptions in Sections 2 and 6 are taken from the live Aicoo codebase (the /api/v1 route handlers, the agent-v04 runtime, the MCP tool set, and the memory/heartbeat modules), not from marketing copy.
• Case study: Relay's design claims are sourced from its public repository (README, PRD, docs/DEVPOST.md, docs/AICOO-USAGE.md) and its server-only Aicoo client (lib/aicoo.ts).