AI Automation as Code · v0.6.0

Tools for agents.
Or the agent harness itself.

Type-safe framework for AI automation. Build the tools an agent uses, or the harness itself, with the same fluent DSL.

morning-brief.tscron trigger

1craft()
2  .id('morning-brief')
3  .from(cron('0 9 * * 1-5'))
4  .transform(summarise)
5  .to(mail())

Same body. Different trigger. Change one line.

IBounded by design

Hands, not keys.

Agents have deleted production databases trying to do their job. Routecraft capabilities are bounded by design: typed inputs, authorize(), per-tool guards, the same code in test and prod. The agent gets the hands you choose, not the keyring.

The keyring

Hand the agent raw tools and hope for the best.

// Typical agent SDK setup
const agent = new Agent({
  tools: [
    bashTool(),
    browserUse({ allowAll: true }),
    computerUse({ allowAll: true })
  ],
})

// The agent decides what to run.
// Including DROP TABLE, rm -rf,
// or leaking the connection string.

One bad prompt away from a production incident.

The hands you authored

Give the agent named capabilities and nothing else.

// A capability that drives the agent.
craft()
  .id('triage-inbox')
  .from(mail('INBOX'))
  .to(agent({
    model: 'anthropic:claude-sonnet-4-6',
    system: 'Triage and route inbound support mail.',
    tools: tools(['Direct(publishBrief)', 'Direct(sendDigest)']),
  }))

// One of the bounded hands the agent can reach for.
craft()
  .id('publishBrief')
  .input(BriefInput)
  .authorize({ roles: ['editor'] })
  .from(direct())
  .transform(redactPII)
  .to(http({ url: '/feed' }))

The capability is the boundary. The agent has no other surface.

The DSL is simple enough that an LLM can write the capability for you. You review the capability, not the prompt.

Expose to an agent

IITwo ways to ship agents

Use Routecraft on either side of the agent.

The same fluent DSL builds the tools an agent calls, and the harness that runs an agent. You pick which side you are on. Sometimes both, in the same project.

Tools for an agent

Expose capabilities, let agents call them.

Set the source to mcp() and your capability becomes an MCP tool. Claude Desktop, Cursor, ChatGPT, OpenClaw, Hermes, or any MCP-speaking client can pick it up. Auth, validation, and structured output are part of the primitive.

.from(mcp()) exposes a typed tool
.input(schema) validates before your code runs
.authorize({ roles }) gates per-agent

Expose a capability over MCP

The whole agent

Build the harness. Own the loop.

Set the destination to agent() and the capability becomes the brain. You choose the model, the system prompt, the tools the agent can reach for, and what happens to the result. The DSL is the harness.

.to(agent({ model, system })) picks the model
tools([...]) scopes what the agent can do
.to(direct('next')) composes into longer flows

Build an agent capability

IIIWhat you can wire up

The surface area.

Every adapter in Routecraft, grouped by what they do. Click any name for the full signature, options, and examples. New adapters are built the same way as built-ins.

Sources

Destinations

Transformers

AI

Testing

Need something that isn't here? Adapters are a documented, stable contract, write your own.

IVWhy Routecraft

Thesis

Every primitive an agent app needs.

Type-safety, validation, auth, MCP, composability, structured logging. Production-grade plumbing so you spend your time on the agent, not the boilerplate around it.

Type-safe end to end

Types flow through every operation. The body shape at .to() is inferred from .from() and every transform in between.

One DSL, every trigger

Cron, webhook, MCP, IMAP, channel, file. Swap one line to change how a capability is invoked. The business logic is unchanged.

Native MCP integration

Set the source to mcp() and the capability becomes an MCP tool that Claude Desktop, Cursor, and any MCP client can call.

Standard Schema validation

Bring Zod, Valibot, ArkType, or anything that speaks Standard Schema. Inputs validate before your code runs.

Auth as a primitive

jwks() verifies bearer tokens. .authorize({ roles }) gates capabilities. userinfo hydrates the principal from your IdP.

Compose capabilities

direct() lets one capability call another with full type safety. Build a graph, test each node in isolation.

Structured logging

Every step emits structured events. Pipe them to your log aggregator, or watch them live in the built-in TUI.

Plugin system

Telemetry, AI, mail, custom adapters. Plugins extend the runtime without forking it.

Runs on Bun or Node

The CLI runs TypeScript directly on Bun. Embed in any Node 22+ app via ContextBuilder.

VFrom the blog

From the field.

Tutorials, postmortems, and small notes from building Routecraft in production.

The full archive

ai-agentsorganizationsmcp

AI agents are still single-player. Your organisation isn't.

The personal-assistant wave gave every employee an agent with their own access, their own memory, and their own chat window. That model cannot serve a team. The unit of organisational AI leverage is the governed capability, not the personal agent.