v0.1.2 · Rust · Apache-2.0

# Real workflows.
No theater.

Axocoatl is an open-source agentic runtime, written in Rust. Agents that run, supervise themselves, persist their state, and finish what you start. One 25 MB Rust binary. Your hardware. Your LLM. Your data.

Install → Why Axocoatl
340+ tests 25 MB binary Zero telemetry Ollama · OpenAI · Anthropic · Mistral · Gemini Apache-2.0
What's different

## A runtime, not a framework.

Most agent tooling optimizes for the aesthetic of AI work. We optimize for the unglamorous reality — the work that ships.

### Built for production

Actor-supervised, checkpointed, sandboxed. Survives restarts. Runs as a system service. Never asks you to keep your laptop awake.

### Yours by default

Your hardware, your LLM, your data. Air-gappable. The only network call is the one you wired.

### Real workflows, not chat

A stigmergic event lattice cascades work between agents automatically. Schedules, proactive triggers, multi-step automations. Not "ask the chatbot and hope."

Concept · 30 seconds

## The lattice does the routing.

Every other framework has a scheduler at its center deciding "next, run agent B." Axocoatl doesn't. Agents declare `depends_on` and an event lattice accumulates pheromone-style signals; when an agent's threshold is crossed, it activates itself.

There's no orchestrator. The order is whatever the dependency graph implies. New agent that depends on two others? Just declare it. Nothing gets rewired.

How it works →
axocoatl.yaml

    agents:
      - id: researcher
        provider: ollama
        model: llama3.2
        depends_on: []
      - id: summarizer
        provider: ollama
        model: llama3.2
        depends_on: [researcher]   # activates when researcher completes

    workflows:
      - id: research-and-summarize
        agents: [researcher, summarizer]
        entry_point: researcher

Concept · 30 seconds

## Agents that actually remember.

Most agents are stateless. Axocoatl gives each one real memory: a live session, a daily log it can read back by date, and a neural recall tier with on-device embeddings, so nothing it learns ever calls out to an API.

The part that matters most is core memory: small, agent-editable blocks the agent curates as it works, rendered into its context every turn (the MemGPT model). While it sits idle, a background pass promotes durable facts up into those blocks. Understanding compounds instead of resetting every run.

How it works →
core-memory · agent-curated

    # in the prompt every turn, edited by the agent
    [persona]  How I work, the standards I hold to.
    [human]    What I know about who I'm working with.
    [project]  Durable decisions, conventions, context.

Sessions

## Build with your agents.

The Sessions cockpit is where the work happens. Pick a directory, pick an agent — or a whole lattice — and watch them operate inside a sandboxed copy of your folder. Reading, writing, running commands, with every action streaming into the dashboard. Real products get built here: SaaS, internal apps, libraries, games. The lattice routes; the cockpit executes.

### Sandboxed by default

Every session runs inside a podman container bind-mounted to your folder. The agent sees your code, you see every file it touches. Close the laptop, open it tomorrow — session resumes from the last checkpoint.

### One agent or a whole lattice

Single-agent for focused work, lattice mode when the workflow needs more than one. Same cockpit. The coordination model from Studio extends into the workspace.

### Real tools, real outputs

Read, write, edit, glob, grep. Run commands. Spawn background processes. Open PTY terminals. Every tool call shows up as a chip in the Activity pane with the output collapsible inline.

Install

## One binary. Sixty seconds.

Prebuilt for Linux and macOS, x86_64 and aarch64. The script verifies a SHA-256 checksum before installing anywhere on your PATH.

curl -fsSL https://axocoatl.ai/install.sh | sh

Prefer Cargo? `cargo install axocoatl-cli`. See the install page for Docker and from-source paths.

Automations

## Real workflows. Not demos.

These are real workflows running on the platform today, rendered as they look inside the dashboard's Automations tab. The recurring work that adds up to a margin — not the work that makes a video.

Reads the past week of git activity, opens issues for the next 72 hours, drafts release notes, and posts the draft to a team channel for review.

For each incoming support email: classifies the request, attaches the customer's previous ticket history, and routes the thread with a one-line summary on top.

Reads the team's calendar and the last 24 hours of lattice events. Produces a five-bullet briefing that lands in your inbox at 8am sharp.

See more workflows →

## Ship work, not screenshots.

Install once. Walk through the demo session. Wire your first workflow. The fastest path is the one in the docs.

Install → Read the docs