A kernel of agents, built from scratch. Models, programs, files and you share one tree, and one call reaches all of them.
cargo install fantastic --locked
Aisixteen Fantastic · Open source · Alpha · macOS, Linux & Windows · crates.io · roadmap
Drives any capable model · lives next to your coding agent
The family
Four layers of one product, from the operating system down to the kernel. Here is what each one does.
Built from scratch
Built from scratch at every layer: a kernel library in four runtimes, the fantastic CLI and a browser canvas you can use today, with a desktop app and fantastic OS coming soon. One protocol runs through all of it.
The browser canvas and the terminal UI today. A desktop app and a native Apple client next.
One place to open, start and stop every fantastic, in any skin.
One static binary for macOS, Linux and Windows.
Python, Rust, Swift and TypeScript, held to one contract.
Files, processes, browsers, other kernels and MCP servers, each sealed until opened. A relay comes next.
An image that boots straight into fantastic.
The kernel
Fantastic is a kernel of agents. A model, a program, a file tree, a shell, a browser canvas and the human at the keyboard are all agents in one tree, addressed by id and reached the same way: one call, send. Compute, inference and memory are interchangeable — a step written as code and the same step written as an LLM call plug into the wiring identically.
[{"target": "kernel",
"payload": {"type": "reflect", "readme": true}}]There is no client library. The protocol is the API: every agent answers reflect with what it is, and docs says how to call it. Given only those self-descriptions, an AI wires the system itself.
A recursive tree. Each agent runs a bundle (a handler module) and keeps its state in its own record.
The one primitive: batched, concurrent, each item a kernel task you can ps and cancel, joinable and idempotent by id.
What an agent is, and how to call it — the whole self-description, one round-trip each.
Deny-all and two-sided: a call passes only when the caller’s can_call and the target’s callable_by both grant it.
Every edge to the outside — another kernel, the disk, a process, a browser, an MCP server — is an IO leg, sealed until opened.
Every message lives in a memory store agent; AI agents fold, recall and page their own history.
The engine
The kernel of agents: one verb, a two-sided call gate, a ledger, memory, a scheduler — in Python, Rust, Swift and TypeScript. It is not a harness for one app; it is ready to power any AI app, yours included.
The product
The open-source workbench built on that engine: a browser canvas where you and an AI build, run and wire your own systems. One repo holds both layers — the engine and the harness of Emergent Software.
vLLM, Ollama, the OpenAI Responses API and Anthropic’s Messages API — plus Apple’s on-device model in Swift. Tool calling uses the kernel’s own prompt-taught grammar, so any capable model drives the same verbs.
Files, edits, streams and watches clamped to the running dir; allow-listed commands and PTY terminals; browser and HTTP faces; kernel-to-kernel links; a remote MCP server’s tools as verbs.
Drop bundles/<name>/bundle.yaml plus a program into .fantastic/ and it becomes a new kind of agent — hot-reloadable.
A scheduler, credentials by reference with secret fields masked in records and events, a persistent tree on disk, and a task table with Unix-style ps / cancel.
Nothing is open by default. Every IO leg denies until an operator opens it, grants are explicit on both ends of a call, an agent never raises its own authority, and file access is clamped to the directory the kernel runs in. One root reflect shows the whole landscape.
fantastic canvas
TypeScript · draws the views
One binary · runs the agents, files and processes
$ fantastic canvasOne command opens the canvas.
double-clickOpen a coding agent — Claude, Codex, Aider, opencode — in a terminal cell inside the canvas.
read .fantasticIt doesn’t know Fantastic yet: it reads .fantastic, connects over fantastic mcp and reflects the canvas — every agent and its docs.
buildNow it builds with the same verbs as every other agent — spawning sub-agents, each with its own view, wired by grants.
What you can build
Each cell is a view plus a running backend agent the AI wrote. Grants wire them together, and a click on the page is a send to the agent behind it.
Design mocks on the page, a Blender agent rendering the scene, and the movie streaming back into the canvas frame by frame.
Designed on the canvas as an isolated kernel — AI, docs, memory — then moved off it as a separate headless process on your server. Close the canvas; it keeps answering.
Whatever you imagine. Ultimate creativity is you.
Fantastic and other agent harnesses
What agent frameworks and coding harnesses typically offer as of October 2026 (LangGraph, Microsoft Agent Framework, OpenAI Agents SDK, Claude Agent SDK, Google ADK, CrewAI, Mastra, Pydantic AI, Letta, Claude Code, Codex, Gemini CLI and others), and what Fantastic does instead. “Not built” means exactly that.
Flat async flows — one batch per turn
No loop object. A model pass is one message; a chain continues only when the model sends — to itself or to others. All calls of a turn dispatch at once as one kernel batch, and their replies come back later as one message: flat asynchronous flows between addressable agents, mailbox-style. A chain ends only by the model's own done; silent turns are capped and thought-only turns are rerolled
One prompt-taught grammar on every model
One prompt-taught <call> tag grammar, no JSON on the model path, the same on every provider and local model. A malformed call gets a compiler-style report (line, caret, the form to write); a call written inside the model's thinking never runs
Self-describing agents, read on demand
Every agent answers reflect (what it is) and docs (how to call it, one-liners or detailed). A model drills down on demand, and docs it already read shrink to stubs
500 calls, one kernel batch
Every send is a batch. One turn of 500 calls runs as one kernel batch on every runtime
Every AI is an addressable agent
Every AI is an agent with an id: AI-to-AI sends, fan-out to many recipients, inquiries between AIs. Models build their own durable teams — sub-AIs, workers, schedules — and tear them down. No prebuilt supervisor or handoff presets
The agent tree is the graph
No graph DSL. The graph is the agent tree plus its grant edges, and a node can be code, a model, a process or a file store — interchangeably. Models wire graphs from the agents' own self-descriptions; a scheduler drives recurring flows
You are an agent too — approvals run once
The human is an agent (user). A model asks through inquiry (text, single, multi, confirm) or a plain send and continues when answered; nothing blocks the kernel. Approval splits the rights: a model without the grant proposes a named action, the person who holds it approves, and it runs exactly once under the approver's authority.
Not built: turning a denied call into an approval question automatically
A named run executes once
A kernel ledger: every call and its outcome is a row in a memory-store agent. A named execution is idempotent — a repeat joins it or gets its recorded outcome — with retries and dead letters (listed, acked, never silently re-sent). The agent tree, schedules and conversations are persisted and rehydrate.
Not built: replaying an interrupted turn to where it stopped — an interrupted call becomes a dead letter
Rewind and fork are a projection away
The ledger already holds every conversation row and every tree change, so both are a projection away from rewind and fork.
Not built: the rewind verb, and the record of replaced file bytes — today one undo slot per edited file
Exact recall — no vector search, by design
Every message lives in a memory-store agent (RAM, or SQLite with full-text search in the CLI), per agent, searchable with grep and recall. Durable notes are files the model writes through a file agent. No vector search, by design: similarity is approximate, and a memory read should return exactly what was written
Folds of folds — nothing deleted
Nested folds: the model summarizes spans of its own history, then folds of folds. Nothing is deleted — recall, grep and descending into a fold reach everything; clear is a boundary, not a deletion. The budget is calibrated from the server's own prompt-size reports
A deny-all gate — both ends must grant
A deny-all, two-sided call gate on every agent-to-agent call; every IO leg sealed until opened; file access clamped to the run directory with an allow list; commands allow-listed by regex; secret marks; credentials by reference, bound to one host.
That governs what may be launched; containing a launched process is not built — no OS sandbox, so an allowed command runs with the user's rights
Every dispatch is a task you can cancel
Streamed parts (text, thinking, call drafts) to whoever watches; the receiver can stop a stream. Every dispatch is a kernel task: ps lists them, cancel kills a whole subtree, real OS processes included. Timeouts are per item and never defaulted
A live stream, a ledger and a task table
A live state stream of who sent what to whom, the ledger, the task table, and the canvas views over them. No OpenTelemetry export; evaluation is the e2e suites and an Exercism benchmark
A persisted scheduler, under its own grants
A scheduler (interval-based, persisted, fires under its own grants), command and terminal jobs as kernel tasks, folder-bundle programs as agents. No cron expressions, no hosted platform
MCP both ways, plus its own wire
MCP client (2026-07-28; each remote tool becomes a verb), an MCP server face for coding CLIs (fantastic mcp, stdio), its own WebSocket and REST wire, and kernel-to-kernel bridges, direct or through a relay. No A2A, AG-UI or ACP
One protocol, four runtimes
One protocol in Python, Rust and Swift (in-process on Apple platforms) plus a browser kernel in TypeScript; a single static binary; a contract corpus pins identical behaviour across them
The same call grammar on every backend
vLLM, Ollama, the OpenAI Responses API, Anthropic, and Apple's on-device model — the same call grammar on all; a KV-cache slot table for shared vLLM servers
A terminal UI and a live canvas
A terminal UI and a browser canvas where a model builds live panels, terminals and services and wires them by grants
A folder becomes a new kind of agent
Folder bundles — a bundle.yaml plus a program becomes a new kind of agent, hot-reloaded, self-describing like every other
Coming soon
From the app to the operating system, built in the open. No release dates: each step ships when it is ready and green on CI.
Home lists your fantastics with live status; open, start and stop them.
macOS, Windows and Linux with signed installers; one UI, many skins.
A Debian image that boots straight into fantastic.
Network, audio, power and displays as agents.
Install
cargo install fantastic --lockedNeeds Rust 1.88 or newer and a C compiler (Xcode Command Line Tools on macOS, build-essential on Linux). The canvas page comes prebuilt, so no Go is needed. All four AI backends — vLLM, Ollama, OpenAI Responses and Anthropic — are on by default.
curl -LO https://github.com/aisixteen/fantastic/releases/latest/download/fantastic-aarch64-apple-darwin.tar.gz tar xzf fantastic-aarch64-apple-darwin.tar.gz && sudo mv fantastic /usr/local/bin/
Archives for Apple silicon and Intel Macs, static Linux binaries (arm64 and x86_64) and a Windows (x86_64) zip are on the latest release, with SHA256SUMS beside them.
Open Claude Code, Codex, Gemini CLI or any CLI agent in a project folder and paste:
Run `fantastic` and read what it prints. Explain to me what it is, then ask me how I want to run it.
Run from an agent's shell, fantastic starts in doc mode: it prints its readme and command list, and starts and writes nothing.
fantasticthe terminal UIfantastic canvasthe browser canvasfantastic ai vllm -p PORTthe root AI on a backendfantastic run CMDyour own program in a terminal cellfantastic mcpMCP over stdio for a coding CLIfantastic readme [key]the docsFree and open source under AGPL-3.0-or-later. Alpha: expect sharp edges, and tell us what you build.
cargo install fantastic --locked