atman
Install v1.1.1
Flow DSL · MCP-ready · Turing-complete
Turn AI coding sessions into
▏
atman lets you script, run, review, and observe agent workflows across your CLI, daemon, tools, and codebase — without locking your engineering process inside one chat window.
atman is a code interpreter.
आत्मन् (ātman) — Sanskrit for self, the inner witness that observes thought but is not thought itself. atman watches the LLM's words and acts on them; it is never the LLM. Not a chat wrapper — the .at language is Turing-complete, and the LLM is one node type inside the program.
A language, not prompts
.at is an unambiguous, concrete, inspectable language. You write the agent's workflow as a program — the flow decides what happens next, not the model.
LLM is one node
llm { ... } is a stochastic node. Tool dispatch, approval gates, retry, subflow recursion, context compaction — all deterministic orchestration around it.
Interpreted, not compiled
atman parses .at files, manages their runtime, and emits a typed event trace for every execution. Replay, audit, monitor — all from the interpreter's own output.
Script. Run. Observe.
Three pillars that turn a one-off chat into an engineering system.
Script flows
Write durable agent workflows as .at files. The flow decides what happens next; the LLM executes what it's assigned. Deterministic orchestration in atman's own DSL, not prompt chains.
Run safely
Decide exactly what each flow can touch — read, write, commit, push, or shell. atman rejects anything out of bounds before it ever runs. Local-first; your providers, your tools, your data.
Observe everything
Replay any run, search across sessions, watch costs and tool calls live. Nothing happens in a black box.
How a flow runs.
Every atman agent is a recursive loop written in the .at language — deterministic orchestration around a stochastic LLM. This is a real workflow panel from a live run.
▼ ⚡ workflow · 12 nodes · 1s · ok
└┈┈ ╭─ ✓ agent─╮
╰─────────────╯
├┈┈ ╭─ ✓ ← expr─╮
┊ ╰───────────╯
└┈┈ ╭─ ✓ ← return─╮
╰─────────────╯
└┈┈ ╭─ ✓ ↳ agent_loop─╮
╰─────────────────╯
├┈┈ ╭─ ✓ ⋯ when …─╮
┊ ╰─────────────╯
┊ └┈┈ ╭─ ✓ text_concat(<message>)─╮
┊ ╰──────────────────────────────╯
├┈┈ ╭─ ✓ llm · ttft 1080ms · 81 tok/s · ↓44 ─╮
┊ │ output: │
┊ │ Hello, what can I assist you │
┊ │ duration: │
┊ │ 1.629s │
┊ ╰─────────────────────────────────────────────╯
├┈┈ ╭─ ✓ ⟶ extract_tool_uses─╮
┊ ╰───────────────────────────╯
┊ └┈┈ ╭─ ✓ extract_tool_uses(<message>)─╮
┊ ╰────────────────────────────────────╯
└┈┈ ╭─ ✓ ⋯ when …─╮
╰─────────────╯
├┈┈ ╭─ ✓ is_empty(list[0])─╮
┊ ╰─────────────────────────╯
└┈┈ ╭─ ✓ ← return ─╮
│ duration: │
│ 2ms │
╰───────────────╯
One runtime, every surface.
atman runs in your terminal, as a daemon behind an HTTP API, or embedded — the same flows work everywhere.
Flow DSL
Write agent workflows as .at files — readable, versionable, diffable. Your engineering process, not a prompt someone forgot.
flow agent(goal) -> String {
llm {
model: "smart",
prompt: goal,
tools: [fs.read, fs.edit, bash.spawn, test.run],
retry: 3,
}
}Scoped by design
From pure read to shell escape — you decide what each flow is allowed to do.
Long sessions
atman keeps context manageable on its own, so hours-long workflows stay alive.
Any tool
Connect filesystems, browsers, issue trackers, note apps — anything that speaks MCP.
Memory
Short-term todos, durable plans, and a permanent record of what went wrong.
Run anywhere
In your terminal, as a background service, or embedded in your own app — the same flows work everywhere.
Why atman?
Mainstream code agents are LLM-driven. atman is flow-driven — the code decides, the LLM executes.
| Mainstream code agents | atman | |
|---|---|---|
| Orchestration | LLM-driven | Flow-driven (code decides, LLM executes) |
| Reproducibility | Non-deterministic | Deterministic .at flow, replayable event trace |
| Multi-model | One model per session | Cascade / ensemble / bridge in one flow |
| Tool safety | Prompt-level | 5-tier sandbox, statically checked |
| Session trace | Chat log | Typed events.jsonl, FTS5-searchable |
| Sub-agents | Hard-coded types | Arbitrary subflow, scope-isolated |
| Headless | Limited | JSON-RPC daemon + SSE + bearer auth |
Get started in 30 seconds.
Three ways to install. Pick one.
# shell installer (macOS / Linux) curl -fsSL https://atman.run/install.sh | sh# homebrew brew install W-Mai/cellar/atman-cli
# cargo cargo install atman-cli --locked
# configure & run atman init # scaffold ~/.config/atman/ atman doctor # verify config + providers atman # launch the TUI
Set an API key via env var (ANTHROPIC_API_KEY / OPENAI_API_KEY) or inline in ~/.config/atman/config.toml:
[models."deepseek/deepseek-v4-pro"] provider = "anthropic" api_key = "sk-..." context_budget = 1000000
[alias.smart] model = "deepseek/deepseek-v4-pro"
Tip: atman can run tools that edit files and execute commands. Start in a disposable repo until you trust your configured tools, and scope each flow to only what it needs.
Build agents like engineering systems.
Not chat transcripts.
Dual-licensed under MIT or Apache-2.0 · github.com/W-Mai/atman