$ open-source agent runtime
Describe an agent.
Get a workload.
tiny is a CLI and MCP server. Describe an agent in Claude Code — tiny builds it into flows of Kubernetes operators that run on your cluster. kubectl get pods shows you your agent.
no hosted sandbox — those are your pods, your namespace, your cluster
one prompt, end to end
What actually happens
Not a metaphor — this is a real flow, with the components tiny picks, the wiring it validates, and what your cluster shows afterwards.
"Take GitHub release webhooks, summarize the changelog with Claude, and post the summary to #releases in Slack."
every edge checked against real port schemas — a wrong mapping fails the build, not your 3am webhook
what people build
Agents with a job
Anything that watches, reasons, and acts is a flow away. Each of these is built from the same prompt-to-workload loop, out of stock modules.
On-call triage agent
Watches cluster events, drafts a diagnosis with the LLM, posts it to the on-call channel — restart waits for a human yes.
Support inbox agent
Reads incoming email, retrieves matching docs by embedding, drafts a reply — queued for approval before anything sends.
PR review agent
Git webhook in, diff summarized and reviewed against your conventions, comment posted back to the pull request.
Nightly research digest
Cron kicks off a crawl of feeds and APIs, the LLM condenses what changed, one email lands before standup.
Data quality sentinel
Queries production tables on a schedule, flags anomalies with reasoning attached, files the report to a spreadsheet.
Release-notes agent
The flow above, kept: webhook to summary to #releases — with traces for every release it ever announced.
Finished agents are shared as solutions — install one into your cluster, widgets and dashboards included, then reshape it by prompt.
no black boxes
You can read what it built
Every agent lands as a flow: typed nodes, labeled edges, live state. Open it in the editor and the logic is just… there — what watches, what thinks, what asks a human, what acts. If a run misbehaves, you point at the hop.
run #482 · event_watch 0ms → js_eval 2ms → router 1ms → llm_complete 1.9s → ask 41s, human → workload_restart 230ms · trace clean
this one restarts crashlooping pods — after a person says yes. the flow is the documentation; the trace is the audit log
production is the default
A runtime, not a demo
Everything an agent needs to survive contact with production ships in the runtime — not left as an exercise.
Every hop recorded
Each message through each edge is traced. Drill from a failed run to the exact port that rejected it. Secrets are redacted in traces.
Sample data travels with the flow
Pin a real trace as a scenario and every rebuild verifies against it. Flows ship green on first build, not after a week of poking.
Transient failures self-heal
Components mark which errors are transient; edges retry exactly those. Durable hops requeue instead of dropping — messages don't vanish.
Human-in-the-loop
The ask component pauses a flow with a form the runtime authors on the fly — approve, edit, or reject from the dashboard.
Dashboards from ports
Any port becomes a widget — chat with your agent, watch tables and charts fill, wire buttons to signals. No frontend work.
Errors point at the edge
Live telemetry per node and per edge. An error badge filters the graph to what's failing; replay the signal once it's fixed.
architecture
No magic to outgrow
tiny is three honest pieces. If you know Kubernetes, you already know how to operate, monitor, and secure it.
- ▸A module is a container image running as an operator — one pod per module, reconciling its own
TinyNodeCRDs. - ▸Components are goroutines inside the module pod; cross-module hops travel over NATS.
- ▸Agents are CRDs — GitOps them, RBAC them,
kubectl describethem like anything else you run.
capabilities
16 modules, 93 components — or write your own
Install a module and its components appear in the palette; prompt-built agents install missing capabilities on demand. Distribution is a static index.yaml in a git repo — publish yours with tiny repo add, no marketplace approval, no gatekeeper.
Modules are built on the tiny SDK — a Go struct with typed ports becomes a component; a GitHub release becomes a version.
mcp-native
Your editor is the console
tiny ships as an MCP server with the full lifecycle as tools — Claude Code, Cursor, or any MCP client can build, run, debug, and evolve agents. The web editor is there when you want a canvas; it's never required.
Debug loop stays in the conversation: run it, read the trace, fix the edge, run it again — without leaving your editor.
Your cluster can run agents now.
One brew install and one prompt away. MIT, no hosted anything.