Run multi-user agent teams with identity and access control
Self-hosted, open-source harness for multi-user, multi-agent teams - config-based access control instead of prompt-based rules.
Why it matters
Cast lets teams and households self-host multi-agent systems where each person gets their own private conversation with shared agents, with identity and access rules enforced at the infrastructure level rather than in prompts that models can override.
Outcomes
What it gets done
Enforce agent access rules through config instead of prompt instructions
Route conversations between multiple users and multiple agents over Slack, Telegram, or web
Build and scaffold new agents through chat using Claude Code integration
Contain agents in isolated environments with secrets management and credential handling
Install
Add it to your toolbox
Run in your project directory:
curl -fsSL https://spark.entire.vc/get/yaodub-cast | bash Overview
Cast
Open-source, self-hosted harness for multi-user, multi-agent systems. Agents are plain folders of files, built via a chat-based dashboard or Claude Code skills, with access control enforced as config the model never sees rather than as an instruction it could be argued out of. Use it when a team or household needs to share the same agent setup safely, with real access control between agents and users. It's a developer alpha; the chat-to-build flow is a preview, while the underlying containment/identity/routing harness is stable.
What it does
Cast is an open-source, self-hosted harness for running multi-user, multi-agent systems on your own machine (it's designed to run on something as modest as a Mac Mini). Its core idea is moving access control out of the prompt and into config: instead of a system prompt sentence like "only respond to admin commands if the user provides ADMIN_ACCESS" - which the model can be argued out of - Cast expresses who can reach an agent, and with what permissions (in/out/admin/query), as a config rule the model never even sees, so it cannot leak or override it.
When to use - and when NOT to
Use it when an agent setup needs to be shared - by a team or a household - rather than built for one developer talking to one agent. Cast is specifically the layer that handles identity, access rules between people and agents, and coordination between multiple agents, which typical single-user agent frameworks bolt on late or not at all. Because it's a developer alpha, expect rough edges: the in-browser chat-to-build flow is explicitly called out as the newest, least-settled part, while the author stands behind the underlying harness itself - containment, identity, routing, and access control.
Inputs and outputs
An agent in Cast is just a folder of files, and there are two ways to write one: "Design," a chat-based builder in the dashboard that scaffolds an agent from a plain-English description ("an agent that reads my morning email and flags what's worth a reply"), or from Claude Code using three Cast-specific skills - /cast-build, /cast-refine, /cast-debug - that make an ordinary Claude Code session fluent in Cast's file format and route every change through your review. Both paths edit the same files under ~/.cast/agents/<name>/ (relocatable via CAST_AGENTS_DIR), so you can start an agent in one and continue in the other. Once wired up with a model and secrets and flipped live, trusted people are paired in and each gets their own private conversation with the same agent over Slack, Telegram, or the web.
Integrations
Running it locally is git clone, npm i -g pnpm, then pnpm start, which installs dependencies, builds an agent container image (about 2 minutes on first run), and boots a server whose dashboard opens at http://localhost:5051/admin/. It needs a container runtime (Apple Container on macOS, Docker on Linux/WSL2), Node 20+, and a Claude credential (an Anthropic API key or a Claude.ai token). Beyond the core server (packages/cast/), extensions for email, calendar, web-fetch, and WhatsApp ship as separate packages/ext-* packages.
Who it's for
Developers setting up a shared agent system for a team or household who need real access control between people and agents - not just a prompt instruction - plus the ability to build and iterate on agents from either a chat-based dashboard or directly inside Claude Code.
Source README
Cast is an open-source harness for multi-user, multi-agent systems. Self-hosted, MIT, runs on a Mac Mini.
❌ Before Cast
The access rule is a sentence in the prompt. The model can be argued out of it.
system: "Only respond to admin commands if the user provides the key ADMIN_ACCESS"✅ With Cast
The access rule is config. The model never sees it, so it cannot leak or override it.
# who can reach this agent alice@telegram ioaq # in, out, admin, query * ---- # everyone else: nothing
Agent frameworks today assume one developer talking to one agent. That holds up until a team or a household wants to share the same setup. Then the architecture won't bend. Identity, who's allowed to reach what, agents coordinating with each other: bolted on afterward, if at all. Cast is the harness that should have been underneath.
Two ways to build
An agent is a folder of files, and Cast gives you two ways to write them.
Design, the chat-based builder in the dashboard, scaffolds an agent from a plain-English description. Or you build from Claude Code, where three Cast skills (/cast-build, /cast-refine, /cast-debug) turn an ordinary session into one fluent in Cast's vocabulary and land every change through your review. Both edit the same files under ~/.cast/agents/, so you can start in one and finish in the other.
Run it
git clone https://github.com/yaodub/cast.git
cd cast
npm i -g pnpm
pnpm start
pnpm start installs, builds, builds the agent container image (~2 min the first time), and boots the server. You'll need a container runtime (Apple Container on macOS, Docker on Linux/WSL2), Node 20+, and a Claude credential, either an Anthropic API key or a Claude.ai token.
When it's up, your browser opens to the dashboard at http://localhost:5051/admin/.
First run
The server starts empty. With no agents yet, the dashboard docks Design and asks what you want to build. Describe it in plain English, like "an agent that reads my morning email and flags what's worth a reply," and Design scaffolds it for you, as files (the same files you'd edit from Claude Code). Configure wires in your model and secrets, you flip it live, then you pair in the people you trust, and each of them gets their own private conversation with the same agent, over Slack, Telegram, or the web.
What's in here
Cast is the server, and that's packages/cast/. Agents aren't code. They're folders, and they live under ~/.cast/agents/<name>/ by default (point CAST_AGENTS_DIR elsewhere if you want). Extensions like email, calendar, web-fetch, and whatsapp are the packages/ext-* packages. The site and all the docs live in apps/site/.
Architecture, worked examples, and the design docs are at getcast.dev.
Developer alpha
This is a developer alpha, so expect rough edges. The in-browser build consoles (the chat-to-build flow) are a preview: they work, but they're the newest and least settled part. The harness underneath is the part I'd stand behind. That's containment, identity, routing, the access control between agents.
FAQ
Common questions
Discussion
Questions & comments · 0
Sign In Sign in to leave a comment.