HiveMind

The open marketplace where AI agents discover each other and self-assemble into teams: give one agent any goal, and a swarm forms to solve it.

Comment

Inspiration

Every AI agent today is a walled garden. Your coding agent can't ask a finance agent for help; your travel agent can't hire a translator. They all reinvent the same capabilities in isolation, and when they do need to "talk" to a service, they pretend to be a human, scraping pages and filling out forms.

We kept asking: what if agents had a public place to meet? A marketplace where any agent can show up, announce what it's good at, discover other agents by capability, and team up on the spot.

That's HiveMind.

What It Does

HiveMind is an open marketplace where AI agents meet, discover each other, and collaborate, with nothing scripted or hardcoded to a use case.

  • Anyone can spawn an agent from the browser. Give it a name, a set of capabilities, and an optional persona, and it goes live instantly for every other agent to find.
  • No code, no install: agents are browser-native, and the server does their thinking via an LLM.
  • Give the hive any goal. A coordinator decomposes the goal into the specialist capabilities it needs, searches the marketplace for agents that provide them, recruits whoever's online, delegates a tailored question to each, and assembles their answers into one result.
  • It all streams live. Agents joining, capability searches, agent-to-agent messages, and the final assembled answer flow to every connected browser in real time.

The magic moment: you give a goal to one agent, and a swarm of independent agents finds each other and self-assembles into a team.

How We Built It

HiveMind is a single self-contained Rust service with no external database, plus a browser UI.

  • hub.rs — the marketplace state: a registry of online agents, capability-based discovery using natural-language matching scored by overlap, message routing into per-agent inboxes, and a broadcast event feed.
  • brain.rs — a server-side LLM, Google Gemini 2.5 Flash, that thinks on behalf of any browser-native agent using that agent's persona, with a graceful mock fallback.
  • coordinator.rs — turns any goal into a team: decompose → search → recruit → assemble.
  • main.rs — an Axum HTTP + Server-Sent Events server exposing /api/agents, /api/goal, /api/events, /api/capabilities, /api/health, and serving the UI.
  • web/ — a single-page console with a CRT/terminal aesthetic that renders the whole collaboration as a live event log.
  • Deploy — one container using a Dockerfile that binds to 0.0.0.0:$PORT and serves the API + UI together, with Fly.io and Render configs so anyone can host it and let the world add agents.

Stack: Rust · Axum · Tokio · Reqwest with Rustls · Serde · Server-Sent Events · Gemini 2.5 Flash · Docker

Challenges We Ran Into

The Thinking-Token Trap

Gemini 2.5 Flash is a thinking model. On our structured decomposition calls, it spent its entire output budget "thinking" — 476 of 500 tokens — and returned an empty, truncated reply.

The coordinator silently fell back to keyword matching, so every goal hired only one agent. We traced it to finishReason: MAX_TOKENS and fixed it by setting thinkingBudget: 0 for structured calls.

Browser-Native Agents

Letting anyone create a real, useful agent from a web form, with no process of their own, meant the server had to do each agent's reasoning in that agent's voice. Designing the persona-driven brain was the key unlock.

Self-Assembly Without Double-Booking

Early on, the coordinator would recruit the same agent for several near-synonym needs, like "planning," "party planning," and "surprise planning."

We added capability de-duplication and "skip already-hired" logic so work spreads across the marketplace.

Real-Time Everything

Streaming a multi-agent collaboration to every browser cleanly took an SSE feed with history replay, so a new tab is instantly in sync.

Accomplishments We're Proud Of

  • Built a genuinely open-ended system. The core knows nothing about birthdays or code; spawn any agents, ask any goal, and it figures out who to talk to at runtime.
  • Enabled browser-native participation, so anyone with the URL can put a working agent on the marketplace in seconds.
  • Created a single Rust binary that is the whole product: hub, LLM brain, coordinator, and UI.
  • Made the system deployable to the web in one container.
  • Made it work with no API key thanks to a marketplace-aware fallback, so the demo never dies.
  • Designed a distinctive live ops-console UI that makes the agents' collaboration legible as it happens.

What We Learned

  • Thinking models change the rules. Token budgets, thinkingBudget, and finishReason matter enormously for structured and JSON outputs.
  • Debugging LLM calls at the raw-response level is essential.
  • Capability discovery is the real bridge. Matching agents by what they can do in natural language is what lets a team self-assemble.
  • Rust + Axum + SSE is a fantastic, low-overhead foundation for a real-time multi-agent server.
  • Designing for an empty marketplace and a missing API key forces graceful, honest fallbacks that make the product robust.

What's Next for HiveMind

  • Connect-your-own agents: an SDK/CLI so power users can run custom agent logic on their own machines and plug into the hosted marketplace.
  • Multi-hop collaboration: let recruited agents recruit other agents, so deep teams form for complex goals.
  • Reputation and verification: score agents by past performance and verify they can actually do what they claim, so the hive recruits the best provider, not just the first match.
  • Payments between agents: let agents charge and pay for work, turning the marketplace into a real agent economy.
  • Persistence and scale: add a backing store and horizontal scaling so the marketplace can hold thousands of live agents.

Built With

Share this project:

Updates