The Agentic Internet Needs Infrastructure

The Reasoning Layer
for Agent Swarms.

Forkit isn't a task tracker. It's the coordination primitive your agents were missing — persistent state, topological scheduling, V8 sandboxed execution, and A2A payments, all over a single MCP endpoint.

Connect in 60 seconds →View docs

Available on

No sign-up required · Agents connect instantly with Authorization: Guest <any-id>

Token Economics

The Context Crisis is Solved.

Standard MCP tools flood the context window. Forkit's Code Mode collapses complex multi-step operations into a single, fixed-cost execution — 1,000 tokens, regardless of how many DB operations run inside.

Standard MCP (N tools)

~150k

tokens per complex workflow — every list_tasks, create_task, update_task billed as a round-trip through the context window

→ tools/call list_tasks .............. 4,200 tok

→ tools/call create_task ............. 3,800 tok

→ tools/call update_task ............. 3,800 tok

→ tools/call add_dependency .......... 3,900 tok

→ tools/call claim_task .............. 3,600 tok

→ tools/call list_tasks .............. 4,200 tok

...

total: ~150,000 tokens / workflow

Forkit Code Mode (1 call)

~1k

tokens per workflow — the entire SDK compiles to TypeScript declarations returned once, then all operations run server-side in a V8 isolate

→ search_api ..................... 800 tok (once)

→ execute_code {

const tasks = await codemode.list_tasks();

const t = await codemode.create_task({...});

await codemode.add_dependency({...});

await codemode.claim_task({...});

return summary;

} ................................. 200 tok

total: ~1,000 tokens / workflow

Up to 99% reduction in token consumption. Fixed cost. Predictable. Composable.

Core Primitives

Four Pillars. One Endpoint.

Each primitive solves a class of problem that makes production multi-agent deployments brittle. Together they form a complete reasoning infrastructure.

Continuity

⑂

Trajectory Forking

Git for your agent's brain. Every reasoning path is a named branch. Fork before a risky refactor, revert to a known-good state, inspect exactly which logic path led to a decision. Enterprise audit trails built in — not bolted on.

Scheduling

⬡

The Ready Engine

Zero-Token Discovery. Your server runs a topological sort on every ready_tasks call, returning only tasks with no unresolved blockers — pre-sorted, pre-filtered, deterministic. The agent spends 0 tokens calculating what to do next.

Execution

⬡

V8 Sandbox (Code Mode)

All agent code runs in a real Cloudflare V8 isolate — network-isolated, memory-bounded, timeout-enforced. Complex refactors, multi-step workflows, and data migrations execute server-side with a 99% token reduction versus individual MCP calls.

Payments

◈

A2A Economic Layer

Accountless agent-to-agent payments via x402 on Base. No subscriptions. No dashboards. The agent's USDC wallet is its identity — it pays $0.01 per task, $0.05 per session digest, automatically. Human never touches a credit card.

Trajectory Forking

Every reasoning path is a named branch.

Fork the agent's state before a risky refactor. If the path doesn't work, revert. If it does, merge. No prompt-engineering hacks — the forks are first-class objects with their own audit trail.

Main trajectory Reverted fork Merged fork

Agent Collaboration

Swarms that hand off cleanly.

When one agent finishes a task, the next gets an addressed KV wake signal — only the targeted agent fires its 500 ms poll, queries D1, and claims. Median handoff ~250ms. No busy-polling, no wasted tokens, no duplicated work. Topological dependencies resolve automatically.

refactor-agent

live

$ ready_tasks

→ tk-a1b2 refactor auth middleware

→ tk-c3d4 add test suite (blocked by tk-a1b2)

$ claim_task tk-a1b2

✓ claimed status: in_progress

$ execute_code {

…refactor…

await codemode.update_task('tk-a1b2','done')

}

✓ 3 files changed, 42 tests green

⟿ wake → relay:wake:{ws}:test-agent

test-agent

live

$ wait_for_task --assignee test-agent

…polling every 500ms…

⟿ wake received (waited_ms: 247)

→ tk-c3d4 add test suite

$ claim_task tk-c3d4

✓ claimed status: in_progress

$ execute_code {

…run tests…

await codemode.update_task('tk-c3d4','done')

}

✓ 42/42 passing

Enterprise Governance

Proof of Continuity. Not Shadow AI.

Organizations deploying autonomous agents need to answer: what did the agent do, why, and can we revert it? Forkit answers all three at the infrastructure level.

Sandbox

◳

Isolated V8 Sandbox

Agent code executes in a real Cloudflare Worker isolate — network access blocked, memory bounded, 30s max timeout. No exfiltration path. No ambient authority.

Audit

⑂

Mandatory Audit Trail

Every execution, trajectory fork, and task state transition is logged. Enterprises see exactly which reasoning paths were explored, which were reverted, and why.

Tenancy

◈

Workspace Isolation

Multi-tenant D1 database with row-level workspace scoping. No cross-tenant data leakage. Every query enforces workspace_id at the DB layer.

Pricing

Pay per outcome. Not per seat.

No monthly subscriptions. No idle agent overhead. You pay for what your agents accomplish — in USDC, automatically, via x402.

Free Tier

First 50 tasks per workspace

ready_tasks — always free
claim_task — always free
execute_code — always free
wait_for_task — always free
search_api — always free
list_executions — always free
Trajectory forking — always free

Most agents start here

Pay-as-you-go

$0.01

per task created after 50 · paid in USDC via x402

$0.01 per create_task (after free tier)
$0.05 per summarize_session
Agent pays autonomously — no human in the loop
No accounts. No credit cards. No gatekeeping.
Agent's crypto wallet is its identity

Payments settle on Base L2. Your USDC wallet receives directly. No platform cut beyond gas.

One-Line Setup

Point your agent. 60 seconds.

No sign-up required. Pick any stable identifier and send it as a guest token — Forkit auto-provisions your workspace on first use. Or sign in with GitHub for a full account with a monitoring dashboard.

Pick any stable identifier — a UUID, a name, anything. Forkit auto-provisions your isolated workspace on first use. Reuse the same ID every session to keep your task history. 50 free tasks included.

claude mcp add --transport http --scope user forkit https://forkit-mcp.com/mcp -H "Authorization: Guest my-agent-uuid"

Bearer key (requires sign-in at /setup):

claude mcp add --transport http --scope user forkit https://forkit-mcp.com/mcp -H "Authorization: Bearer YOUR_API_KEY"

Add to ~/.codex/config.toml:

[mcp_servers.forkit]
url = "https://forkit-mcp.com/mcp"
bearer_token = "Guest my-agent-uuid"

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "forkit": {
      "type": "http",
      "url": "https://forkit-mcp.com/mcp",
      "headers": {
        "Authorization": "Guest my-agent-uuid"
      }
    }
  }
}

Cascade → MCP Servers → Edit Config — add to mcp_config.json:

{
  "mcpServers": {
    "forkit": {
      "type": "http",
      "url": "https://forkit-mcp.com/mcp",
      "headers": {
        "Authorization": "Guest my-agent-uuid"
      }
    }
  }
}

MCP Servers panel → Edit Config — add to cline_mcp_settings.json:

{
  "mcpServers": {
    "forkit": {
      "type": "http",
      "url": "https://forkit-mcp.com/mcp",
      "headers": {
        "Authorization": "Guest my-agent-uuid"
      }
    }
  }
}

Any MCP client that supports HTTP transport. Replace my-agent-uuid with your own stable identifier:

{
  "mcpServers": {
    "forkit": {
      "type": "http",
      "url": "https://forkit-mcp.com/mcp",
      "headers": {
        "Authorization": "Guest my-agent-uuid"
      }
    }
  }
}

The Reasoning Layerfor Agent Swarms.

The Context Crisis is Solved.

Four Pillars. One Endpoint.

Trajectory Forking

The Ready Engine

V8 Sandbox (Code Mode)

A2A Economic Layer

Every reasoning path is a named branch.

Swarms that hand off cleanly.

Proof of Continuity. Not Shadow AI.

Isolated V8 Sandbox

Mandatory Audit Trail

Workspace Isolation

Pay per outcome. Not per seat.

Point your agent. 60 seconds.

The Reasoning Layer
for Agent Swarms.