v0.1 · Bun-first · for Cloudflare Workers

Write the agent.
ayjnt writes everything else.

Agent-first framework for Cloudflare. File-based routing, auto-generated wrangler config, typed inter-agent RPC, co-located React UIs, and MCP support — so you can ship Durable Object agents without ever opening wrangler.jsonc.

Read the docs Browse examples GitHub

Quick start

One command scaffolds a project with a working agent. A second command starts a local Cloudflare worker you can hit from curl or the Agents client SDK.

New project with minimal or with-ui template
Generated wrangler config, migrations, and entry point
HMR-backed dev server that rebuilds on file-tree changes

terminal — zsh

agents/ — the whole API

agent.tsstate + methods

app.tsxReact UI

middleware.tsauth

agent.ts

The folder is the framework

The shape you draft in agents/ maps 1:1 to URLs, DO bindings, migrations, and the worker entrypoint. There is no config file to author — just files and folders.

agent.ts: One default-exported class per folder. Name + state + methods.
middleware.ts: Applies to descendant agents. Root → leaf chaining, Hono-style next().
app.tsx: Optional React UI. Gets a typed useAgent() bound to this folder.
(parens): Route groups — share middleware without nesting the URL.

What you get

Six tools-in-one: routing, migrations, RPC, UI, MCP, dev loop. None of the glue. click any card for a visual deep-dive

File-based routing

Folder = agent. Nested folders = nested URLs. Route groups share middleware without leaking into the URL.

Git-safe migrations

.ayjnt/migrations.json is committed. Deploy refuses to run from an out-of-sync tree.

Typed inter-agent RPC

getAgent<T>(env.BINDING, id). Native Workers RPC, method autocomplete, exceptions cross the boundary.

Co-located React UIs

Drop an app.tsx next to agent.ts. Generated useAgent() hook syncs state across every tab.

MCP agents built in

Classes extending McpAgent dispatch through McpAgent.serve() automatically. Streamable HTTP + SSE handled.

HMR-backed dev loop

ayjnt dev watches agents/, re-runs codegen on structural change, lets wrangler reload. 26ms rebuilds.

Agents that call each other, typed.

getAgent<T> returns a typed DurableObject stub. Method autocomplete from the target class. Errors propagate across the RPC boundary as exceptions. Rename a method and both sides break at compile time.

native Workers RPC → no HTTP, no JSON round-trip
method autocomplete → from the target class
exceptions propagate → throw in callee, catch in caller

agents/orders/agent.ts ts

// agents/orders/agent.ts
import { Agent } from "agents";
import { getAgent } from "ayjnt/rpc";
import type InventoryAgent from "../inventory/agent.ts";

export default class OrdersAgent extends Agent<Env, State> {
  override async onRequest(request: Request): Promise<Response> {
    const { sku, qty } = await request.json();
    const inventory = await getAgent<InventoryAgent>(
      this.env.INVENTORY_AGENT,
      "main",
    );
    const remaining = await inventory.decrement(sku, qty);
    return Response.json({ ok: true, remaining });
  }
}

Under the hood

Every build is a pure function of your file tree. The pipeline is small and inspectable — peek at .ayjnt/dist/entry.ts any time.

Build pipeline

agents/**/agent.ts
source
scan()
op
.ayjnt/migrations.json
persistent
diff + emit
op
.ayjnt/dist/entry.ts
artifact
wrangler deploy
delivery

Every step is a pure function of its inputs. I/O lives at the edges (scan, readLockfile, writeLockfile). Everything in between is tested as pure data transforms — see src/codegen/.

Build these

Every example in the gallery has a scaffold command, the code you'd add to which file, an animated terminal walkthrough, and the deploy step.

All examples →

$POST /chat/room-1 '{"text":"hi"}'

${ "ok":true, "count":1 }

$GET /chat/room-1

${ "messages":[…] }

Basic agent

One ChatAgent with state, no UI, no middleware. The smallest possible ayjnt project beyond the blank scaffold — adds persistent messages so you can see how state works on a Durable Object.

statehttp

$agentFetch({ agent: 'ChatAgent',

$ basePath: 'chat/' + roomId,

$ host })

Client SDK + basePath

Connect from the Cloudflare Agents client SDK. Explains the path vs basePath gotcha and why server-side getAgentByName matters for identity messages.

client-sdkwebsocketgotcha

root middleware↓

admin gate↓

agent

Multilayer middleware

Root → leaf file-based middleware chain. One `middleware.ts` adds logging + timing headers to every response; a nested one gates a subtree with bearer-token auth. Route groups let you share middleware without nesting URLs.

middlewareauthgroups

OrdersAgent↓

getAgent<InventoryAgent>↓

InventoryAgent

Inter-agent RPC

Two agents talking over Workers RPC via typed `getAgent<T>()`. An Orders agent calls Inventory to decrement stock — full method autocomplete, exception propagation, oversell protection.

rpcmulti-agent

counter — live syncs across tabs

Basic agent UI

Drop an `app.tsx` next to `agent.ts`. The generated `useAgent()` hook is typed to that agent's class and state. Live multi-tab state sync built in — open two tabs, they share state.

MCP tools agent

Build an MCP server for LLM tool-calling. ayjnt detects `McpAgent` as a base class and dispatches through `McpAgent.serve()` automatically — streamable HTTP and SSE transports handled for you.

mcpllm-tools

Ready when you are.

One command scaffolds the project. One command ships it.

Start the docs ayjnt on npm Source on GitHub

Write the agent. ayjnt writes everything else.