AI models have gotten capable enough that all you need to do is write a prompt, give it some tools, and they are able to do real work. A lot of people run personal agents this way today.

The catch is that these agents are designed to work alone. That is fine for a personal helper. It is not how real work gets done.

Nothing substantial is a solo job. Humans split complex problems up and hand the pieces around.

Pile every job onto one agent and it gets worse at each job.

The setup breaks down the moment more than one human operator is involved: these systems are not built for multiple people talking to the same agent.

Agents work best when they are able to work as a team.

I started with OpenClaw

OpenClaw seemed like a good place to start: a single always-on agent running in the background, reachable on your usual chat apps.

It can technically run more than one agent. But the moment I tried to get several working together it buckled.

Contexts bloated. Getting them to coordinate effectively was a fight the whole way.

I spent a few weeks on it before accepting it would not get me there.

What I needed was a better harness. One that gave agents multi-user capabilities and let them work with other agents as well, for true multiplayer. That comes down to three things:

• Real identity: the agent always knows who it is talking to.
• Isolation between people: one person’s history never leaks into another’s.
• Coordination between agents that holds up under real work.

One agent, a whole team

With Cast, an agent is able to keep several conversations going at once without confusing them.

The agent knows you when you message: your history, the project you were stuck on last week.

Your coworker who messages the same agent gets their own history, not yours.

Everyone gets access to the agent’s memory and skills, but each conversation stays private.

You can take this further and set the same agent to adopt different postures depending on who is talking to it. It can be open and casual with your team and more careful with external users, while staying one agent underneath.

Agents that ask each other for help

These agents can also collaborate and ask other agents for help.

You decide who can ask whom, and about what; Cast helps you wire the connections, almost the way you would draw an org chart.

So your assistant never guesses who to hit up or ends up shouting a question at everyone.

When it asks a peer a question, it gets the answer back, not the other agent’s whole memory or its keys.

That is what keeps a team of agents from collapsing into a pile.

Spin one up on a Saturday

You could build out a whole operation this way: dream up a new agent on a Saturday afternoon, design it in chat, and onboard it that same evening.

Every agent sits behind the same fixed boundaries. By making the boundaries explicit, you can iterate on the agent design without worrying about it violating security policies.

That is the bet behind Cast.

Get the foundation right and the plumbing stops being something you have to fuss about, leaving you time to focus on the agent design.

What you get is not a toy agent that forgets you or a contraption that topples the moment things get complicated, but a real team of agents you can lean on, working for you and the people around you.

An agent should be small, light enough to rewrite on a whim. The foundation under it should be built to keep it on the rails.

Try it

Cast is in developer alpha, up on GitHub. The Claude Code path works today:

git clone https://github.com/yaodub/cast
pnpm start

I’m going to write about the choices behind it as I go. The next piece is on how a single agent holds a whole team’s conversations at once and never lets them touch.

It’s rough in plenty of places and missing more. If you try it and something breaks, tell me.

Originally published on the Cast blog.