Concrete example. Earlier this year, as part of the DOGE transparency push, HHS published Medicaid’s payment records: every payment to every billing provider, month by month, 2018 through 2024. About 238 million rows. Sum the payment column and the file says Medicaid paid out 21.8 trillion dollars. The actual program spent about a quarter of that, which you can check against CMS’s own audited reports.

The file is real. The numbers need work.

Doing that work has always meant a team. Someone to decode the files, someone to find where they lie, someone to cross-check the totals, someone to write down what can and cannot be trusted. If you just wanted to know what the data says, there was no good answer short of doing all of that yourself.

healthsets is an open-source experiment built on a bigger bet: AI models can now do that work themselves. Not as autocomplete for a data scientist. The whole job, in days instead of months, and done more carefully than schedules usually allow, because being careful stops being expensive.

You bring the questions. The model develops the domain expertise.

So I ran the experiment. I pointed Claude Fable, Anthropic’s model, at the Medicaid file with one question: who does Medicaid actually pay? (Fable, because nobody has given me Mythos access. If you work at Anthropic and want to fix that, my inbox is open.)

I picked the question and kept veto power over the boring. The rest was the model’s: it acquired the file, found the traps, designed the cleaning rules, and checked its own work against the outside world. Some of what that meant in practice:

• a text encoding trap that crashes standard tools halfway through a file
• a fake provider ID quietly carrying billions of dollars in a single year
• fifty states billing the same hour of care under different codes, which makes some states nearly invisible in national data
• reconciling the cleaned totals against CMS’s audited books, for all seven years
• sorting half a million billing IDs into the real organizations behind them
• a build rule that refuses to publish the report if any company it names is missing its citations

All of that happened inside a week, most of which I spent saying yes, no, and simpler.

The answer to the question surprised me. The report opens by asking you to guess, so I will not spoil it here:

Who does Medicaid pay?

Everything on that page is computed in your browser from a published set of data tables, and every number can be re-derived from them. The tables, the row-level records, and the code are on GitHub, definitions included.

This is the first public piece of healthsets. The pipeline behind it is not ready for release yet. More datasets are coming, because Medicaid is one file in a universe of public data that deserves the same treatment.

If the bet is right, the expensive part of making public data public is now mostly a matter of asking.

There was a catch I did not dwell on then. The way I first built it, you drew the whole org chart up front. Every person who could talk to an agent, granted ahead of time. Every agent-to-agent line, wired by hand.

This post is what running it taught me about that, and what I ended up changing.

The map you don’t know yet

Drawing the map up front works when the team is three agents and you know exactly who talks to whom.

It stops working the moment the team is real.

People show up you did not plan for. A coworker hears about your assistant and messages it. You spin up a new agent on a Saturday and it needs to ask an older one for help.

None of those edges were on the map, because the map was a guess.

I kept ending up in the same bind. Draw it too tight and I spent the week rewiring. Too loose and everything could talk to everything. Neither sat right.

Cast 0.2.0 handled new people with pairing codes. Meet someone, generate a code, send it over, they redeem it. It worked, and it was busywork. Every introduction went through me by hand.

A connection forms when someone knocks

What I landed on in 0.3.0 was to change when an edge gets made: at first contact, instead of at setup.

Someone new messages your agent. Nothing silently opens. The message is held, and the agent turns to you and asks.

The ask lands in your own chat, with the message they sent, so you decide with the actual words in front of you. The sender just sees that their message is waiting.

Approve, and they are in. Reject, and the door stays shut.

Approving once creates a standing grant. The next message flows without asking you again, and you can revoke it later from the access tab.

Agents knock the same way

The same gate covers the agents themselves.

When one agent wants help from another and there is no line between them yet, the request is held exactly like a stranger’s first message. You say yes, and the org chart grows a line.

What builds up over the weeks is the map of who actually works with whom. Not the one I guessed at setup. Every line on it exists because someone needed it once and I approved it.

You can still draw by hand

Pre-wiring still works. When you already know two agents belong together, write the grant and they are connected from day one.

The difference is you no longer need the whole picture before you start. The chart begins as small as you like and fills in as the work arrives.

The org chart stopped being a diagram I maintain. It became a record of what my team actually does.

Try it

Cast v0.3.0 is up on GitHub.

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

Coming from 0.2.0, the migration scripts under scripts/migrations/0.2-to-0.3/ carry your paired users and grants over to the new model.

Still developer alpha, still rough in places. If something breaks, tell me.

Originally published on the Cast blog.

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.