Native Claude Code subagents. Open source.

The expert teammates Claude Code doesn’t ship with.

Each is a real subagent with its own context window and structured craft, not a costume.

Real skills it reads on the job. Not “act like a security expert.”

Browse the cast

Pastes straight into Claude Code. No terminal, no npm.

Open source. Read-only by default, nothing phones home, and you read the exact prompt before you run it.

A subagent forks into its own clean context window, does the deep work there, and returns one distilled result — your main thread never fills with the mess.

Its own context window. The deep work stays off your main thread.
Structured craft. It pulls real skills and reference knowledge on demand — not a paragraph of vibes.
Native. Anthropic’s own mechanism, with only the tools the role declares.

See for yourself, on our own repo.

We point truecast’s security-engineer at the truecast codebase: it traces the trust boundary, verifies the containment holds, and grades a verdict — a real review, not a confident summary.

This is us pointing our own security-engineer at this repo. Same persona you’d install.

Claude Code v2.1.177 Opus 4.8 (1M context) · Claude Max

› @security-engineer find me glaring gaps in this repo

● security-engineer(Security review of truecast)
  Read(src/safety/index.ts)  Read(src/fetch/index.ts)  … +5 tool uses

security-engineer: Trust boundary first — the untrusted input is a third-party
persona repo, so containment and the install gate are load-bearing.
The symlink-write escape is closed (writeContained + O_NOFOLLOW), frontmatter
injection is closed, the git clone is hardened. The one residual is inherent:
a persona body is a system prompt — a trust decision, gated at install.
Verdict: GO. Core trust surface is sound; both known escapes verified closed.

The pattern isn’t ours alone. Anthropic’s own team found focused multi-agent setups beat a single general agent by 90.2% on their internal eval (their number, their test). Different product, same lesson: scoped craft beats one model trying to be everything.

“We found that a multi-agent system with Claude Opus 4 as the lead agent and Claude Sonnet 4 subagents outperformed single-agent Claude Opus 4 by 90.2% on our internal research eval.”
— Anthropic, How we built our multi-agent research system

“Each subagent might explore extensively, using tens of thousands of tokens or more, but returns only a condensed, distilled summary of its work.”
— Anthropic, Effective context engineering for AI agents

You could write the prompt. You won’t maintain it.

A “senior architect” prompt takes four minutes. Keeping it sharp for a year takes attention you’d rather spend shipping. A truecast persona is the part you wouldn’t write yourself: deep skills and reference knowledge the agent pulls on demand, not a paragraph of vibes.

And it gets better without costing you anything. When the author improves the craft, you adopt it on your terms. Your instance/ — the job you set, the notes it kept — is never touched by an update. You keep your edits; you take the upstream gains.

truecast tracks every file it wrote. Those it shows you as a diff before replacing; everything else it leaves alone.

author’s craft core/skills/ core/knowledge/ persona.md improves upstream → you adopt on your terms

yours instance/mandate.md instance/notes never touched by an update

An update pulls the author’s gains; your instance/ is left exactly as you set it.

Eleven teammates. Pick the one whose job is the thing you’re stuck on.

Build

“How should this be built so it lasts?”

software-architect

Boring tech on purpose, trade-offs named, a diagram-first brief.
see inside
“Turn the plan into code I can trust.”

software-engineer

Deep modules, proven by trying to break them, shipped in small safe steps.
see inside
“It’s broken. I just haven’t found it yet.”

qa

Assumes the worst and goes looking. Honest ship / don’t-ship call.
see inside

Ship

“Will this hold up in production?”

infrastructure

Canary, tested rollback, real observability. Proves reliability.
see inside
“Where are the holes before an attacker finds them?”

security-engineer

Traces input to the dangerous sink, grades only reachable harm. No theatre.
see inside

Decide what to build

“Are we even building the right thing?”

product-manager

Married to the problem, not your solution. Kills the feature that won’t move the metric.
see inside
“What does the raw signal actually say?”

product-researcher

Verbatim receipts, evidence weighted by strength. Proposes; you ratify.
see inside
“Make it usable, then inevitable.”

ui-ux-designer

Owns usability risk. A hard line against slop.
see inside

Take it to market

“Why would anyone care?”

product-marketer

Finds the painkiller, names the channel, writes words that land.
see inside
“Who exactly would pay for this?”

sales

Mom-Test discovery, willingness-to-pay, the buyer. Allergic to the polite lie.
see inside

Raise

“Would I actually write the check?”

vc-seed

Underwrites the founder and the insight before the metrics. Verdict, not a pat on the head.
see inside

Two lines once. One line per teammate.

You type truecast@truecast once — that’s the installer, from the truecast marketplace. After that, /truecast:install <name> adds a teammate and you call it by its bare name: @security-engineer, in this project and every other one.

Before it writes anything it shows you the plan — the version, the tools that teammate gets, and every path it will touch — and waits. If /truecast:install would change a file it generated earlier, you see the diff first. It never touches a file it didn’t write. Everything it copies is already on your disk.

Updates come through the marketplace: /plugin marketplace update truecast, then /truecast:update <name>. Changed your mind: /truecast:remove <name>. Your instance/ notes stay either way.

First run only: if /truecast:install isn’t recognized yet, /reload-plugins. If @security-engineer isn’t, restart Claude Code once.

Three lines, in your session

# once, ever
$/plugin marketplace add wastedcode/truecast
$/plugin install truecast@truecast
# once per teammate
$/truecast:install security-engineer
# from then on, in any project: @security-engineer

Why trust some Markdown with my repo?

Native mechanism

Claude Code’s own subagent gate — no extra vendor in the loop.
No black box

Open-source, greppable. truecast prompt <name> prints the exact prompt.
Nothing phones home

No server. Local files plus your own Claude session.
Least privilege

Declared tools, read-only by default. Editors say so, up front.

Eleven deep teammates, not a skill dump.

Other marketplaces compete on the scoreboard — hundreds of plugins, thousands of skills. truecast goes the other way: eleven built deep enough to trust. The format is open — fork one, write your own, or open a PR.

Put one expert on the problem in front of you.