Real workflows.
No theater.
Agents that coordinate without an orchestrator, remember across runs, and never leave your machine. An open-source Rust runtime: one 26 MB binary, your hardware, your model, your data.
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.
Coordinates itself
Agents self-activate on a stigmergic event lattice. A finished agent's signal pushes the next one past its threshold. No central orchestrator handing out tasks.
Actually remembers
Four memory tiers and agent-editable core memory, with on-device recall. Checkpointed, so a crash resumes from the last step instead of starting over.
Yours by default
Your hardware, your model, your data. Zero telemetry, air-gappable, one binary. The only network call is the one you wired.
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 →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: researcherAgents 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. While it sits idle, a background pass promotes durable facts up into those blocks. Understanding compounds instead of resetting every run.
How it works →# 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.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. The 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.
Four capabilities, no slides.
Short clips from the running product: the coordinator building a team to fit a goal, memory that survives a brand-new conversation, a crash that resumes from its checkpoint, and the network trace that shows nothing leaves your machine.
One binary. Sixty seconds.
Prebuilt binaries for macOS (Apple Silicon and Intel) and Linux (x86_64 and aarch64). The script verifies a SHA-256 checksum before installing anywhere on your PATH.
Prefer Cargo? cargo install axocoatl-cli. See the
install page for Docker and
from-source paths.
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.
Ship work, not screenshots.
Install once. Walk through the demo session. Wire your first workflow. The fastest path is the one in the docs.