Metatoy Studio — an AI-native software factory
Metatoy is a solo studio run through a multi-agent software factory: cost-tiered model routing, token-spend telemetry, and autonomous execution windows that make solo delivery across six active repos possible. It's my answer to what it means to operate a company through an agent.
What I built
Metatoy is a solo studio run as a multi-agent software factory — the operating model that lets one person ship multiple products across many repos without dropping the quality bar. It's my answer to what it means to operate a company through agents.
It's not a product; it's a repeatable, measured, human-gated way of working: persona-cast agent pods, a cost-tiered model ladder, spec-first delivery, verification skills, and a token-spend ledger.
How it works
Every substantial task becomes an approved spec first. A run then casts a pod (design / developer / QA execution roles plus review seats), executes down a cost-tiered model ladder, and verifies against reality (screenshot / simulator / compile gates) — with a human owning every merge and deploy. Work, cost, and outcomes are logged to a ledger and to a persistent memory so the system improves run over run.
How I built it
Built on Claude Code plus a bespoke layer: custom agents and skills, MCP servers wiring the pods to real tools (hosting, browser, Figma, wikis), and an operating contract in checked-in docs.
- Cost-tiered model routing: a default tier for thinking and judge-facing writing, a workhorse tier for build, and a bulk tier for mechanical fan-out — fan-out goes down the ladder to match task value to cost.
- Verification skills: deterministic screenshot / simulator / compile checks so agent output is checked, not assumed.
- Telemetry: a ledger measures tokens and wall-time per pod, so throughput is a number.
- Infra: a self-hosted PaaS on cloud hardware, durable workflow orchestration (Temporal), and a file-based agent memory with a hygiene protocol.
Features — how the studio works
The studio is the proof, not the pitch: a one-person operation that ships iOS apps, web products, and backend infrastructure by running like an engineering org staffed by AI agents. It's also the clearest evidence of how I design agentic systems — the operating model, the guardrails, and the evaluation rigor are all things I built and run daily, not slideware. The estate it drives today: around 30 repositories, 8 backend services, a self-hosted AI skill-server plus 6 connected MCP tool servers, and 19 user-facing surfaces (4 iOS apps, several web apps, marketing sites, and a Figma plugin). Pick an area to see what it is and how the studio uses it.
This is the core competency: designing autonomous systems that do real work without going off the rails. Work starts as an approved spec, then fans out into dev pods — a lead agent plus workers on isolated git worktrees with non-overlapping file partitions, a QA pass against a definition-of-done, and one integrated PR. Agents are cast down a cost-tiered model ladder (a strong model for planning and judging, cheaper models for bulk fan-out), an idle loop researches and runs sandboxed experiments while the queue is clear, and every irreversible action — deploy, publish, merge, spend — is gated on a human. The pattern is load-bearing across the portfolio: the self-verifying the agentic migration, TattleTown's moderation pipeline, and the publishing platform's automation model of propose, then a human approves.
Where the product thinking comes from. Parallel pods, each cast with personas chosen for deliberate cognitive diversity, run an opportunity-solution-tree brainstorm blind to each other — so when they converge, that agreement is real signal, not groupthink. Dozens of raw ideas collapse to a handful, each carrying its riskiest assumption and cheapest experiment, and a human decides what graduates. Ideation is kept structurally separate from evaluation so judgment never contaminates divergence — the same discipline a good design review needs.
Strategy backed by evidence, not vibes. A sourced, dated feature audit across an entire tool landscape, scored on a dozen capability axes, feeds a gap analysis — where the product is uncontested, where it competes, and where not to fight — that a review council turns into concrete roadmap placement. Every unverified cell is flagged and any claim headed for marketing is gated, so the roadmap can survive scrutiny. Run in depth for Sorb's design-token tooling landscape.
A fifteen-year through-line that answers "is the AI real or recent?": it starts with sentiment classification on emerging-platform data in 2010, runs through shipping ML-based content recommendations inside the publishing platform in 2018, and lands on today's LLM classification and evaluation systems. In production that's the AI Support Triage agent — a learned rulebook the model reads, tuned against a locked golden set until routing accuracy climbed from 54% to the mid-70s — and TattleTown's moderation, which returns a structured verdict and fails safe to a human on anything legally sensitive. A separate patent-pending product models how people rate and rank things, growing a knowledge base of rating methodologies into a reusable rubric engine.
Shipping GenAI features that are safe enough to put in front of users. In woords, season stories, clues, and completion "findings" are authored by an in-house LLM pipeline that writes in a locked per-season voice, with no-spoiler and content-safety checks on every line; the three-tier hint system is LLM-written in that voice and every tier must clear a deterministic "never reveal the answer" gate before it ships. In Sorb, the AI layer explains, reskins, repairs, and renames design tokens by riding the running app's live token↔component binding graph rather than being a generic model wrapper — always AI-proposes, human-reviews, live-verifies, never auto-applied. And I'm precise about the line: the puzzle generation itself is a deterministic constraint solver, not ML, and there's no image-model GenAI anywhere — knowing what shouldn't be AI is part of the judgment.
Systems designed to compound, which is what separates a demo from a moat. The woords tone flywheel turns every rating on a sampled clue into training signal — good clues become few-shot exemplars, bad ones become filter rules — so the machine writes more on-voice and the human reviews less each cycle. The AI Support Triage correction flywheel feeds every human correction back as fresh ground-truth evaluation data. And the studio meters itself: every agent pod logs cost and outcome to a ledger, and a roll-up reports token spend and "work done per 100k tokens" to steer operating rules and future casting — paired with a memory-hygiene protocol that keeps the studio's own knowledge base from rotting.
I stand up my own AI infrastructure rather than renting all of it, which is where the systems-engineering shows:
- Temporal — a self-hosted durable-workflow engine (retries, scheduling, day-long waits, crash-resume). The woords season-generation pipeline runs on it end to end — select words → solve grids → write clues → generate hints → a hard automated QA gate → a human-approval gate → publish — with a shadow domain-watch and the TattleTown moderation workflow alongside. It's live infrastructure; the woords content pipeline is proven end-to-end against staging and not yet pointed at production data.
- LangChain — a self-hosted skill-server: LangChain.js exposing a library of Claude-backed "skills" run over the local Claude CLI, so it needs no API key and carries no per-token cost. The split is deliberate — Temporal orchestrates and owns durability, LangChain just thinks on request. It backs the woords content-generation skills and a marketing/publishing skill family.
- ElevenLabs — voice synthesis for narration, supplying the voice-over for woords' "Lattice" season cut-scenes (a literary-noir surveyor register) that ships in the app. Today it's a founder-run render workflow rather than an automated API integration.
Questions this project answers
What does an AI-native workflow actually look like day to day? AI is the substrate I build on, not a sidecar. I run an entire solo studio through a multi-agent factory on Claude Code, where every substantial task becomes an approved spec, then a pod of agents executes it down a cost-tiered model ladder and verifies the result before a human merges. It is the primary interface for getting real work done across about six repos, which is why I can ship products, design, and backend as one person.
How do you decide an agentic system is reliable enough to trust? I make the system prove it against reality rather than against its own confidence. Every pod runs through deterministic verification gates (screenshot, simulator, and compile checks) so output is observed working, not assumed, and a human owns every merge and deploy. I also instrument the factory with a token and wall-time ledger, so I can see what a run actually cost and whether a change made it better or just more expensive.
What does responsible design of an autonomous system look like to you? It means autonomy with a person always on the trigger. Even the studio's unattended execution windows are built so a human signs off on every merge and deploy, and the verification gates sit between the agent and anything that ships. I keep the operating rules and model-routing policy in checked-in docs so the behavior is legible and auditable, not folded into a prompt no one can review.
How do you work at the seam between design and engineering? I come from a long design-to-engineering career, so I built that seam into the factory rather than treating it as a handoff. Pods reach design context directly through a Figma MCP connection, and frontend work is checked with screenshot and simulator verification skills so the rendered result gets a design-trained review before it lands. The point is that taste and correctness are both enforced in the same loop instead of being argued about after the fact.
Results
- One operator ships across ~6 active repos / products through the same factory.
- Proven output: a published npm design-token toolchain (Sorb), two iOS apps to the App Store, and this portfolio site — all delivered solo.
- Throughput is measured (tokens + wall-time per pod), not estimated.
Skills
AI / Agentic
| Multi-agent orchestration | I designed a persona-cast pod model where each substantial task casts a slate of execution roles (design, developer, QA) plus review seats, announced before the run and coordinated toward a single merge. |
|---|---|
| Cost-tiered model routing | I built a routing policy that sends thinking and judge-facing writing to a default tier, build work to a workhorse tier, and mechanical fan-out down to a bulk tier, so task value is matched to model cost on every run. |
| MCP tooling | I wired the pods to real tools through MCP servers (hosting, browser, Figma, wikis, mail) so agents act on the actual environment instead of describing what they would do. |
| Claude Code as the substrate | I run the whole studio on Claude Code daily as the primary interface for getting work done, extended with custom agents, skills, and workflow scripts checked into the repo. |
| Autonomous execution windows | I built human-gated 'away' modes that let a pod run longer multi-step work unattended while a human still owns every merge and deploy trigger. |
| Agent memory system | I maintain a file-based memory with a hygiene protocol (state-decay, overlap-merge, snapshot-before-delete) so the factory carries context and lessons run over run instead of starting cold. |
| Prompt and skill design | I authored a library of bespoke skills (screenshot and simulator verification, job-scan, project-refresh) that encode repeatable procedures the pods invoke by name. |
Frontend
| React / static site delivery | The studio ships web surfaces through the same factory, including this portfolio site and product marketing pages, built and deployed by pods rather than by hand. |
|---|---|
| Visual verification skills | I built deterministic screenshot and simulator verification skills (Playwright harnesses, an iOS sim loop) so UI output from agents is checked against a rendered result, not assumed correct. |
| Design-to-code seam | I connected the pods to Figma through MCP so design context feeds implementation work directly, keeping a design-trained eye in the loop on frontend output. |
Backend / Infra
| Self-hosted PaaS | I run the studio's hosted services on a self-managed PaaS (Coolify) on cloud hardware, with the deploy step gated behind a human confirmation. |
|---|---|
| Durable workflow orchestration | I stood up a Temporal stack to make long-running agent workflows durable and resumable rather than dying with a single session. |
| Networking and tunnels | I front internal services with Cloudflare tunnels so NAS-hosted components (a skill server, workflow engine) are reachable without exposing the host. |
| Token-telemetry ledger | I built a ledger plus rollup tooling that records token spend and wall-time per pod, so studio throughput is a measured number instead of a guess. |
| MCP servers | I operate several MCP servers as the tool layer between the agents and real infrastructure, which is what lets a pod deploy, query, and verify against live systems. |
Leadership
| Solo operating model | I designed and run Metatoy as a company encoded in an operating model, so one person ships across roughly six active repos and products without dropping the quality bar. |
|---|---|
| Spec-first delivery | I enforce a command vocabulary where every substantial task becomes an approved spec before any code, keeping intent and scope settled before a pod executes. |
| Human-gated governance | I built the factory so a human owns every merge and deploy, with verification gates in between, which is how autonomy stays safe to run. |
| Measured throughput | I treat the studio's own output as something to instrument, pricing pods by tokens and time so decisions about where to spend agent effort are grounded in data. |