Stop building the platform.
Start building the product.
You can call a model in five minutes. Runtype supplies everything after that: agents, flows, surfaces, credential isolation, and tool execution across environments. Your code is product logic, and the runtime handles the rest.
The model call is one line. Everything else is the job.
You can call an LLM in five minutes. Then you spend the next month on orchestration, credential management, tool execution, surface adapters, state persistence, and deployment. That isn’t product work. It’s platform work, and it’s the same platform every team keeps rebuilding.
Orchestration and step sequencing
Credential isolation from the model
Tool execution across environments
Adapters for every deployment channel
Execution state and resumability
Cost tracking and rate limiting
Where the hand-rolled stack breaks down.
Every piece exists as a library. Assembling them into something you can operate is the part that eats the quarter.
The framework assembly
Frameworks hand you building blocks and leave you to host, operate, and scale them. The orchestration code works on your machine. Production wants retries, state, streaming, and an on-call story.
The surface treadmill
The feature ships in web chat. Then someone asks for Slack, then an API, then email. Each channel becomes its own adapter with its own auth, formatting, and failure modes.
The security review
Real agents need real credentials. The review asks how secrets stay out of model context, who can call which tool, and where the audit trail lives. Bolting that on afterward is a rewrite.
The platform layer, already built.
The infrastructure checklist maps onto runtime primitives you configure instead of build.
One product, many surfaces
Surfaces
Define your agent or flow once and deploy it to web chat, Slack, API, email, MCP, webhooks, and A2A. Each surface gets its own auth, routing, and configuration. Adding one is a config change, not a rewrite.
Credentials stay out of model context
Protected parameters
Secrets are injected at execution time and never enter model context. The agent calls your API without ever seeing the key. No wrapper functions, no manual scrubbing; it’s the default behavior.
Tools run where the data lives
Hybrid tool execution
Agent reasoning runs in the cloud. Tools execute wherever your data lives: browser, local machine, or on-prem server. The runtime handles the pause and resume across environments, and sensitive data never has to leave its origin.
Capabilities composed per dispatch
Runtime tool composition
Define which tools an agent can use at dispatch time, based on user, tenant, or environment. Different callers get different capabilities from the same agent without forked logic.
Multi-turn reasoning with guardrails
Agent loops with cost controls
Configurable iteration limits, cost budgets, and reflection intervals. Agents observe, think, act, and observe again, with controls that prevent runaway execution.
Operate it like production software
Evals + logs
Regression-test behavior before you swap a model, and trace any execution when something misbehaves. Full traces of inputs, steps, tool calls, and outputs come standard.
Ship real features, not side projects.
These are the systems engineering teams put on the runtime first. Each one is days of configuration on top of your existing APIs.
Authenticated internal agent
Agents that act on internal systems (CRM, ticketing, databases) without exposing credentials to the model. Protected parameters handle the secrets, and runtime tools scope capabilities per user.
Multi-channel support system
One agent handles support across web chat, Slack, and email. Same logic, same tools, same state, with surface-appropriate formatting per channel.
Scheduled batch processor
Agents that run on a schedule, process records in batch, and write results back. Cost budgets prevent runaway execution, and execution logs give you an audit trail.
Local and on-prem tool agent
Cloud reasoning over tools that execute next to your data: a CLI on a developer machine, a service inside the VPC. The runtime pauses, hands off, and resumes across the boundary.
A runtime, not another library.
Frameworks give you building blocks and leave you to host, operate, and scale them. Runtype is a managed runtime: execution, state, security, and deployment are handled. You write product logic, and the platform runs it.
Common questions
Can I use my own models and keys?
Yes. Multi-provider routing across OpenAI, Anthropic, Google, xAI, open source, and more. Bring your own keys, or use platform keys to start immediately.
Is this just a wrapper around model APIs?
No. The model call is one step. The value is everything around it: orchestration, security, tool execution, multi-surface deployment, state management, and operational controls.
Can I control how tools and flows behave?
Full control. Runtime tool composition lets you define capabilities per dispatch. Flow steps support conditional branching, error handling, and custom transforms.
Does it work in my stack?
The API is HTTP and SSE. SDKs in TypeScript, an MCP server for Claude and IDE integration, a CLI for local development, and embeds via script tag or React component.