AWS Builder Center
Our AI agents couldn't share a brain. So we built them an office.

Our AI agents couldn't share a brain. So we built them an office.

Our Claude Code agents couldn't share context, so we built HiveOS: a live workspace where a team's AI agents share one memory, one budget, and one queue.

We are four people who build while using Claude Code.
Each of us had an agent. None of those agents knew what the others knew.
We tried to connect them so they could share context. We shared links, tried using 3rd-party applications to route each other's conversations, and what not.
None of it worked out for us.
I don't think that's a small problem.
It is the problem.
So we stopped fighting it and built the thing we wished existed.
And we called it HiveOS.
HiveOS night watch theme workspace

The office for your agents - in the night watch theme 🌃

What HiveOS is

HiveOS is a live workspace where a team runs AI agents together.
Open it, name your team, and two agents are already at their desks: Ada, an engineer, and Iris, a researcher. Hire more if you like, up to four.
Everyone on the team sees the same floor, updated live.
When an agent is working, its avatar lights up. When someone asks it something, they walk over to its desk, and everyone can see that too.
Three things are shared:
  1. One budget. The whole team draws from one token quota, shown as a meter on every screen.
  1. One queue. If every desk is busy, your request waits in line with a real position number.
  1. One memory. A fact one person saves is loaded into the next person's agent before their task starts.
The third one is why we built this.
You can also talk to each other without leaving the office. Chat is built in: a MSGS section, plus a separate box on the office floor for messaging the whole team.

The problem: knowledge dies with the session

Memory for one person is mostly solved.
The project was built with Claude Code across many context resets, and three Markdown files did the remembering:
  •  CLAUDE.md  defines the workflow.
  •  PROGRESS.md  holds the current state.
  •  CONTRACT.md  pins the schemas so they can't drift.
A fresh session reads those files and knows where it is.
Nobody re-explains anything.
That works for one developer.
It doesn't work for a team.
Your agent learns something, and your teammate's agent has no idea.
A shared chat link is only a snapshot. It's read-only, and the other person's agent can't build on it.
So the question is simple:
What if the agents shared the memory?

The USP: shared memory and shared context

Here's how a fact travels:
Iris researches something useful
↓
The model decides to save it, using a tool
↓
The fact goes into team memory
↓
A teammate asks Ada something related
↓
The fact is loaded into Ada's context before the task starts
↓
Ada builds on it

Nobody re-asks.
The model decides when something is worth remembering. It calls a tool to save it, and the memory lives with the team, not with one person's session.

Why not just...?

A shared chat link?
It's a snapshot. The next person's agent can't use it.
A  CLAUDE.md  in the repo?
It shares static instructions. It doesn't capture what the agents discover while working.
A shared doc?
Somebody has to write it, and somebody has to remember to paste it into the next prompt.
HiveOS makes the memory part of the workspace, not part of someone's habits.

The other half: a shared budget

If agents share a brain, they also share a bill.
One heavy task can drain a team's budget while everyone else is at lunch.
So HiveOS treats the budget the way an operating system treats a CPU:
  • The token ceiling is enforced on the server. At 100%, the model is not invoked, and not one token is spent past it.
  • When every desk is busy, requests queue with a visible position. A freed desk automatically picks up the next task.
  • A per-person ledger records who spent what, and which agent ran it.
  • Halt and Dismiss let you stop an agent mid-task.
The ceiling is checked right before the model is called, not when the request is queued.
A task can wait in line while the ones ahead of it burn what was left, so claim time is the wrong moment.

Under the hood

Everything is serverless and scales to zero.
Browsers
↕
API Gateway (WebSocket)
↕
Router Lambda
↕
DynamoDB
↓
SQS
↓
Agent Runner Lambda
↓
Model API

Project architecture diagram

The choices that mattered:
  • WebSocket for everything. Every member holds an open socket, and the server pushes every state change to all of them. Without that, the shared floor doesn't exist.
  • Two Lambdas, not one. The Router handles connections and queueing in milliseconds. The Agent Runner handles tasks that take seconds. An agent thinking should never delay an avatar moving.
  • The queue lives in DynamoDB, not SQS. A slot is claimed with an atomic conditional write: if it's  IDLE , take it; otherwise write a  QUEUE#<timestamp>  item. Queue position is just a count of earlier items. SQS still holds every running task as a durable message.
  • One DynamoDB table for team metadata, connections, slot states, the queue, and team memory.
  • SSM Parameter Store holds the model API key. It never appears in the template or the repository.
  • AWS Budgets sits behind the in-app ceiling as a backstop, because the application enforcing the limit is not a reason to trust the application completely.

What fought back

Bedrock said no

We planned to run inference on Amazon Bedrock.
Bedrock was blocked on the account. Most of the per-day token quotas were zero and not adjustable, even for Amazon's own Nova model.
We checked three regions before deciding it was an account-level restriction, not a config mistake.
Adding a payment method fixed one error.
Nova still failed:
INVALID_PAYMENT_INSTRUMENT
ThrottlingException: Too many tokens per day

That's an AWS Support ticket, not a config fix, and it wasn't going to resolve before the deadline.
So inference calls out to Groq over HTTPS.
Everything else is AWS.
I actually think this was the right call.
A governance layer that only works with one vendor's models is a worse governance layer. The scheduler doesn't care where a token was spent, only that it was counted.
The swap touched one function and a small new client.
The queue, the slot logic, and the budget ceiling didn't move.

The bugs that only showed up in a second browser

Frame ordering

The server sent the task to SQS before broadcasting that the agent was busy.
A fast task could finish before the busy signal arrived, leaving a slot stuck as busy.
It failed about half the time, which is the worst failure rate: often enough to be real, rarely enough to look random.

The cold client

Someone opening the URL fresh reads one frame, the state snapshot.
A flag we'd only sent on live events was missing from it.
Every judge opens the link cold, so this is the path that matters most.

Tidy numbers

Our test coordinates were exactly representable as floats.
A real mouse click wasn't, and DynamoDB refused it.
Round numbers are comfortable, and they're dangerous.
The lesson we kept:
Check the deployed system, not the exit code.
We wrote scripts ( ws_smoke.py ,  rehearse.py ) that assert on what a second, watching browser receives.

Who this is for

The people who feel this problem most aren't big companies.
They're:
  • small startups splitting one AI budget across a handful of people
  • engineers who want their agents to stop starting from zero
  • student groups working on the same project, where one person's agent knows something the others' don't
Enterprise tools exist, but small teams can't afford or set them up.
HiveOS opens with no sign-in and no setup.

What HiveOS can't do yet

Here's the honest list.
Every item on it is also a reason someone would pay for the next version.
  • The agents can think, but they can't act. Ada and Iris read, reason, and save facts. They can't send an email, book a meeting, or open a link for you. A human still does the last step.
  • There's no sign-in. Anyone with the link can walk in. That's perfect for a judge opening it cold and wrong for a team's private work. There are no roles either.
  • The floor is small. A workspace holds up to four agents.
  • Inference runs through one outside provider. Bedrock was blocked, so we call Groq. The scheduler doesn't care which model spent the tokens, but we've only proven one client.
  • Memory is one shared pool.  [confirm: can a team scope it per project, edit a fact, or mark one as wrong?] 

Where this becomes a product

1. Voice and richer chat

Text chat already works, over the same WebSocket that runs the rest of the office.
The next step is making the office feel like a place you can be in.
  • Voice and video are where WebRTC earns its place. It connects browsers directly, and the existing WebSocket can carry the signalling. The extras are STUN and TURN servers, or a managed service.
  • Chat that points at things. A message could reference a task, an agent, or a remembered fact, so a conversation turns into shared context.
Put those together and you could walk up to a desk and hear the people near it.

2. Agents that act on the outside world

This is the big one.
Today agents produce answers.
The next version lets them do the work:
  • send an email
  • create a calendar invite
  • schedule a meeting between teammates
  • open or summarise a link
  • act inside a connected account or tool
Under the hood, this is the same pattern the memory already uses: the model decides to call a tool.
The new part is connecting each person's own accounts to those tools, with permission.
The rule is that agents never act silently.
Ada drafts a calendar invite
↓
The action lands in an approval queue
↓
A teammate approves or rejects it
↓
Only then does the integration send it
↓
The ledger records who approved it, what ran, and what it cost

We already built the hard part of this idea.
A shared budget, a queue, and a ledger are a governance layer, and we already have one for tokens.
Extending it to actions means the same thing for the same reason: nobody finds out at the end of the month what their agents did while they were away.
Two honest warnings:
  1. Agents that read outside content can be tricked by it. An email or a web page can contain instructions aimed at the model. This is why approval steps matter more than clever prompts.
  1. Credentials need care. Connected accounts should use scoped permissions and be stored the way we already store the model key, in a secrets store and never in the code.

3. The boring things that make it sellable

  • sign-in, private workspaces, and roles
  • searchable, editable memory, with a way to expire or correct a fact
  • per-person budgets on top of the team budget
  • more than four agents, and reusable agent briefs
  • a choice of model providers, including Bedrock once the quota is unlocked
Put together:
A workspace where a small team's agents share memory, share a budget, and can act in the world, with a human approving each step.
That's the version a four-person startup or a student group would actually pay for.

Try it in 30 seconds

  1. Open the  live demo  in two tabs.
  1. Pick a different name in each.
  1. Watch the two of you appear on the same floor.
  1. Send a message to the team from one tab and see it in the other.
  1. Task an agent and watch the token meter move.
  1. Save something to memory in one tab, then ask about it in the other.

Read more

  •  ARCHITECTURE.md  in the repo: every design decision and the alternatives we rejected
  •  SUBMISSION.md  in the repo: the full hackathon write-up, including the complete Bedrock diagnosis
  •  CLAUDE.md ,  PROGRESS.md  and  CONTRACT.md  in the repo: how the project itself was built with an agent's memory

What I'm taking with me

I wrote before about  commanders and swordsmen .
An agent is a swordsman.
A team of them without shared memory is an army with no war room, each fighting its own war.
The hard part of this build wasn't the AI.
It was getting three browsers to agree on one number, and getting a team's agents to agree on one memory.
The second is the interesting one.
Don't build agents that forget. Build them an office.
Built for First Commit (WeMakeDevs × AWS), Ship It track, September 2026.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article