// infrastructure for agentic software

Make agents
actually dispatchable.

A small, deterministic runtime for running AI agents as isolated, observable, resumable workloads — without turning your platform into a distributed-systems science project.

dispatchable / runtime
$ dispatch run agent.plan --id job_7f2
┌───────────────┐ │ DISPATCH │ └───────┬───────┘ │ ┌───────▼───────┐ │ ISOLATE │ └───────┬───────┘ │ ┌──────────▼──────────┐ │ EXECUTE │ │ [████████░░] 82% │ └──────────┬──────────┘ │ ┌───────▼───────┐ │ RESUME │ └───────────────┘
sandbox ready 42ms
policy loaded 8ms
checkpoint committed 19ms

$
01
runtime primitive
hidden magic
agent workflows
/dev/null
unnecessary infra
01 — The problem

Agents are easy to demo. Production is the hard part.

Retries, isolation, timeouts, credentials, state, observability and failure recovery quickly become everyone’s problem. Dispatchable makes those concerns explicit primitives instead of framework folklore.

01 / ISOLATION

Run safely

Give every workload a bounded execution environment with a clear lifecycle and explicit capabilities.

02 / LIFECYCLE

Pause. Resume. Recover.

Treat execution as a durable state machine. A process dying should not mean your agent forgot what it was doing.

03 / CONTROL

Know what happened

Structured events, checkpoints and policy boundaries make agent behavior inspectable by default.

02 — Runtime model

One job.
One boundary.

Dispatchable keeps the core deliberately boring: accept work, establish a boundary, execute, emit state, checkpoint, and finish. Everything else composes around it.

Continue with GitHub →
 ┌──────────────────────────┐
 │        DISPATCHER        │
 └────────────┬─────────────┘
              │
              ▼
 ┌──────────────────────────┐
 │        WORKLOAD          │
 │                          │
 │   agent → tools → llm    │
 │                          │
 └────────────┬─────────────┘
              │
      ┌───────┴───────┐
      ▼               ▼
 CHECKPOINT        EVENT
      │               │
      └───────┬───────┘
              ▼
        RESUME / DONE
03 — Principles

Small surface area.
Strong guarantees.

Designed for engineers who would rather understand the system than memorize another framework’s edge cases.

A

Explicit boundaries

Security and resource constraints belong in the runtime contract, not scattered through application code.

B

Portable execution

Keep orchestration separate from the workload. Swap infrastructure without rewriting the agent.

C

Failure is normal

Design around interruption, retries and partial progress instead of pretending they will not happen.

// start here

Build agents that survive contact with reality.

Read the model. Challenge the assumptions. Then ship.

Continue with GitHub →