Tardigrade is a typescript framework for building modular agents around an immutable event log. It is built on Effect TS and is inspired by React's declarative approach to building user interfaces.
Agents that can self-improve
As models get increasingly smart, they will be capable of writing their own harnesses to improve themselves (Meta-Harness). A harness that is too rigid and complex is a bottleneck to this. We need something more composable, and easy to author.
We took inspiration from React. React derives its component tree and declared effects from state. Tardigrade applies the same idea to agent harnesses. Each component derives a view and enabled transitions from an event log.
{ view, transitions } = f(event log)
Why Tardigrade
Composable harness. Add tools, code execution, budgets, compaction, and replies as independent components.
Strongly typed, built on Effect. Typed services and Layers make each component's dependencies explicit. A missing service fails during compile.
Crash proof. A durable host derives unfinished work from the stored log.
Serverless. All you need is a durable store, no process has to stay alive. Any new invocation reads the log, runs the transitions it owes, and settles.
Inspect and improve every run. Log as core supports native debugging, replay, and experiments with state forked from any checkpoint.
Quickstart
Install Tardigrade and initialize an editable template actor. Use Bun 1.4 or later. If you are using a coding agent, the Tardigrade skill can help.
If you have an existing agent application, follow the migration guide to move its harness, history, API, client, and deployment configuration.
bun add -g tardie@latest
tdg init tardie-agent --template quickstart
cd tardie-agent
bun run dev
tdg init configures the first provider and model. Edit actor.ts to describe the agent. The CLI guide covers non-interactive setup, more providers, and deployment.
From another shell, discover the actor's methods, allocate a root thread, and send it a message:
tdg methods
tdg thread create --name quickstart
tdg call message '{"text":"What is the weather in Singapore?"}' --thread quickstart
Deploy the generated Worker with either platform CLI:
Cloudflare:
bunx wrangler deploy
Celld:
celld deploy --config celld.jsonc
See the Cloudflare and Celld guides for platform configuration and secrets.
Build your own harness
bun add tardie
You can use npm install tardie instead. Install tardie@next to test a release candidate.
Create a component
An agent is made of components. Each component owns a machine with initial, step, and output. Its state retains the information from prior events that can affect its future output. An agent view includes system fragments, tool bindings, and context policy. This component gives the model one tool and owes no autonomous work:
initial creates private state. step updates it for each event. This component ignores events and preserves its state. output derives its view and enabled transitions. Each tool keeps its specification and handler together. answer records the result. Replace the sample result with your deployment API.
An offered tool follows this lifecycle:
The component adds recent_deploys to the agent's composed view.
infer includes its specification in the model request.
The model calls it. Tardigrade records ToolCalled.
Tardigrade runs the attached handler and records ToolReturned.
infer includes the result in the next model request.
Compose an agent
Mount the component beside the built-in parts that this task needs:
import { actor } from "tardie/core"
import { agentMethods, agentsPackage, budget, budgetAuthority, caller, codeMode, compaction, infer, outputValidateOnce, system } from "tardie/agent"
import { fetchPackage, filesPackage, workspacePackage } from "tardie/code"
const instructions = system(
"You are a release analyst. Identify risky changes and recommend the safest next action."
)
const releaseAnalyst = actor({
// name supplies the actor's stable identity.
name: "release-analyst",
// methods declare how the world can communicate with this actor.
methods: agentMethods,
// components implement those methods and derive transitions from the actor's private log.
components: [
// infer handles messages as model loops composed by children.
infer([
instructions, // system prompt
deploys, // provides recent_deploys tool and paired handler
// budget scopes the tool-call limit to the codeMode subtree
budget([
codeMode([ // sandboxed code execution
filesPackage(),
fetchPackage(),
agentsPackage(),
workspacePackage()
])
], { authority: caller() }),
compaction(), // bounded model context
outputValidateOnce // validates structured result once without correction
]),
budgetAuthority() // budgetAuthority handles requestBudget for this actor.
]
})
actor gives the composition a stable name and callable methods. infer turns its child components into an agent loop and inherits the host's model policy unless its infer options narrow it with models.
compaction() uses the selected model's catalog window. It summarizes at 80 percent and retains a 50 percent tail. Pass fireRatio and keepRatio to change those values. Each checkpoint records the policy it applied.
codeMode([...components]) exposes its packages through one execute tool.
budget([...components]) meters tool calls within its subtree. caller() sends escalation requests to the invoking actor, and budgetAuthority() handles them locally.
This agent can inspect deployments and files, fetch sources, delegate research, and analyze results with JavaScript. Change the package list to create another harness.
Each action and result becomes an event that every component can interpret.
Run the composition
Bind a model and durable SQLite host
The three code blocks form one program. Run it in a project configured by tdg init or tdg setup, with the provider credentials available in the environment. This example registers the adapter for OpenAI Responses and compatible chat completions; use the adapter for your configured protocol.
bunModelServices reads the model policy from wrangler.jsonc and binds inference and platform services. createBunHost stores actor instances under storage. The method call returns the completed result; retries with the same key return the same invocation. Use a new key for each new request.
How durability works
Every message, model action, tool result, and checkpoint lands in the log. Component machines consume those events and derive keyed transitions from their current state.
Sₙ₊₁ = step(Sₙ, eₙ₊₁)
The host runs transitions with unrecorded keys. It appends their events and repeats until the agent rests.
If the process stops during recent_deploys, the log still contains its unanswered ToolCalled. host.recover() replays the log through the component machines, derives the same key and input, then runs the handler again. Live execution only steps the machines with newly appended events.
External effects have at-least-once execution. Each keyed result is recorded once. Providers can use the transition key as an idempotency key.
Tardigrade 是一个 TypeScript 框架，用于围绕不可变事件日志构建模块化 agent。它构建在 Effect TS 之上，借鉴了 React 的声明式组件模型，从日志而非可变状态推导 agent 的视图和可用转换。