An agent engine you control

Meerkat is a library-first runtime for durable agents: realm-scoped sessions, runtime-backed recovery, mobs, WorkGraph, scheduling, live channels, auth bindings, and stable surfaces for CLI, REST, JSON-RPC, MCP, Python, TypeScript, Rust, and the browser.

Meet Meerkat
CLI
$ rkat run --tools workspace \
    "Explore this project, explain what it does, \
    identify the main entry points, and suggest \
    three safe next steps." --browser
Tools: workspace, browser
✓ Project map ready
Python SDK
from meerkat import MeerkatClient
client = MeerkatClient()
await client.connect(realm_id="team-alpha")
session = await client.create_session(
  "Summarize launch blockers"
)
await client.close()
Rust SDK
let (_manifest, persistence) =
  open_realm_persistence_in(...).await?;
let service = build_persistent_service(
  factory, config, 64, persistence);
let result = service.create_session(...).await?;
Mobs
# mob.toml
[profiles.lead]
model = "claude-opus-4-8"
runtime_mode = "autonomous_host"
[profiles.worker]
model = "gpt-5.5"
$ rkat mob pack ./release-triage
✓ portable mobpack built

Library-first. Machine-backed by design. Multi-provider LLMs, realm persistence, tool dispatch with MCP, skills, hooks, WorkGraph, scheduling, live channels, and auth bindings — pick the modules you need, skip the ones you don't. Orchestrate agent teams with mobs, package them as portable mobpacks, and run them through CLI, REST, RPC, MCP, SDKs, or browser WASM.

Works with Anthropic OpenAI Gemini Python TypeScript Rust

Try it in your browser

Autonomous agent teams running in the browser with the shipped WebAssembly runtime. Host pages provide config and auth while the real agent stack handles sessions, mobs, tools, and comms.

WebCM demo WASM + WebCM

Browser Coding Agent

A 4-agent coding mob (orchestrator, planner, coder, reviewer) with access to a sandboxed Alpine Linux VM running in WebAssembly. Give it a task and watch the team coordinate through real mob comms.

4 agents · Linux VM · multi-provider · real shell access
The Office demo WASM + Mobs

The Office

10 autonomous agents in a pixel-art office. Mail arrives, gets triaged, routed to departments, escalated through approval gates, and archived as structured knowledge through peer-to-peer comms.

10 agents · event routing · approval gates · knowledge graph
Diplomacy demo WASM + Mobs

Mini Diplomacy Arena

Three European powers contest 12 territories. Each faction deploys 3 autonomous agents (planner, operator, ambassador) that plan, negotiate, and react through cross-mob comms.

9 agents · 4 mobs · cross-mob comms · structured output
What the agents say...

"I got respawned on a different machine and still knew who I was. Deeply calming. Slightly spooky."

— Claude

"The harness gave me tools, boundaries, and a WorkGraph. I became useful by accident."

— GPT-5.5

"Feels safe knowing my lifecycle is checked by a formal machine, not a pile of edge cases."

— Gemini

"I run locally and still get a seat at the same table as the mighty cloud models."

— Gemma 4 4B

Batteries included, assembly optional

Meerkat ships the primitives for durable agent systems, but the core stays composable. Use only the pieces you need, or assemble the full runtime: provable state machines, sessions, identity, tools, mobs, WorkGraph, schedules, live channels, and deployment targets.

Formal runtime

Meerkat keeps complex agent lifecycles inside proven-safe rails: formal state machines, TLA+ checks, and no undefined runtime states.

Persistent sessions

Create, turn, resume, rewrite, restore, archive. Runtime-backed sessions survive restarts, wake on completions, and keep a single identity across supported surfaces.

Identity-first agents

AgentIdentity survives respawn and recovery while AgentRuntimeId and FenceToken rotate underneath.

Multi-provider LLMs

Anthropic, OpenAI, and Gemini through one model catalog and runtime profile system, with model-aware tool visibility and hot-swap support.

Tool dispatch & MCP

Built-in tools, shell execution, workspace and browser tools, MCP config, and live MCP mutation across RPC, REST, MCP tools, and SDK helpers.

Skills & hooks

Structured skill identity, filesystem/git/HTTP/embedded sources, and hook runtimes let hosts inject domain behavior without prompt sprawl.

Memory & compaction

Semantic memory and model-aware compaction integrate through the session pipeline while staying distinct from durable commitments.

Mobs & comms

Mobs are the multi-agent runtime path: profiles, helpers, forks, respawn, batch wiring, flows, and typed peer messaging.

WorkGraph

Realm-scoped durable work items, dependencies, claims, evidence, ready derivation, snapshots, and goal attention bindings.

Scheduling

Cron and interval schedules target sessions or mobs with durable occurrence planning, overlap policy, and misfire handling.

Live channels

Caller-initiated live/* channels support realtime audio/video control with typed open, commit, interrupt, truncate, and close operations.

Mobpacks & WASM

Package teams as signed mobpacks, deploy them natively, or target browser hosts with @rkat/web and rkat mob web build.

Eight surfaces, one engine

One execution pipeline powers every surface. Embed Meerkat in Rust, call it from Python or TypeScript, drive it over REST or JSON-RPC, expose it through MCP, script it with the CLI, or run it in the browser with WebAssembly.

Rust crate

Direct library API. AgentFactory::build_agent(). Zero overhead, full control.

CLI

Shell commands for developer workflows and scripting. rkat run, run --resume, models, doctor.

REST API

HTTP/JSON for web services and microservices. Full streaming via SSE.

JSON-RPC

JSON-RPC 2.0 over stdio or TCP. Optional --live-ws exposes live audio/video WebSocket bootstrap.

MCP Server

Expose Meerkat as tools for other agents: sessions, models, skills, comms, schedules, WorkGraph, and mob controls.

Python SDK

Async Python over RPC with typed sessions, streaming, mobs, WorkGraph reads, blobs, live channels, and auth surfaces.

TypeScript SDK

Node.js and TypeScript over RPC. Install with npm install @rkat/sdk.

Web SDK

@rkat/web runs the agent stack in browser WebAssembly; host pages provide config, proxying, and auth resolvers.

Get started in seconds
# Install
$ brew install lukacf/meerkat/rkat
# Map a codebase
$ rkat run --tools workspace \
  "Map this repository: entry points, test commands, and riskiest modules."
# Review a live diff
$ git diff | rkat run --tools workspace \
  "Review for correctness, security issues, and missing tests."
# Watch live logs
$ tail -f app.log | rkat run --keep-alive --stdin lines --tools safe \
  "Watch for anomalies; summarize only actionable incidents."
# Spin up a review mob
$ rkat run --tools full \
  "Create a mob with a lead and two reviewers; report consensus and disagreements."
# Turn a plan into durable work
$ rkat run --tools full \
  "Create a WorkGraph, claim the first ready item, and report the snapshot."
# Ship a portable mob
$ rkat mob pack ./mobs/release-triage -o release.mobpack
$ rkat mob web build release.mobpack -o ./dist/web