4.4 KiB
Observations
Filesystem as interface — if you know how to operate a filesystem, you know how to operate ollie. Any tool that reads and writes files — ed, vim, Python, cat, a shell script — is already a fully capable ollie client. No SDK, no API, no protocol to learn.
Simple front-ends — A TUI reads chat, writes prompt, polls state. There is no protocol to implement.
Crash resiliency — Memory (m/) is written to persistent storage outside the session. If a session crashes or is killed mid-task, it is not lost — a fresh session picks up where the previous one left off.
Code execution tool — Anthropic describes code execution as "a foundational primitive for building high-performance agents." ollie takes that literally: execute_code is the only built-in tool. It is a pipeline executor — single stage, multi-stage, and parallel fan-out are all the same primitive. New capabilities are added by dropping a script into t/ and a skill in sk/.
Parallel execution — execute_code accepts a steps array of pipeline stages. A {parallel: [...]} stage fans out concurrently within the pipeline. Sequential stages chain stdout → stdin. All stages accept inline code and named tool scripts interchangeably.
Radical transparency — The rendered system prompt for any session is readable at s/{id}/systemprompt — the prompt the agent is actually running with, not a reconstruction. The prompt parts that compose it live in p/; the agent can read its own instructions but cannot modify them.
Discoverability — ls s/{id}/ shows every control surface. cat t/idx and cat sk/idx list available tools and skills. cat help explains the rest.
Composability — execute_code stages chain the same way Unix pipes chain programs. Sessions chain by reading s/{id}/chat and writing to another session's prompt or fifo.in.
Passive memory — Every session's chat history accumulates at s/{id}/chat, searchable with grep. An agent doesn't need to actively decide what to remember. This extends across sessions: an agent can search another session's chat for answers that have already been worked through.
Sub-agents — subagent_spawn implements fork-join over the b/ namespace: spawn N specialized agents with a shared prompt, wait for all to complete, collect results in submission order. For heterogeneous parallel delegation (N agents, N different prompts), use a {parallel: [...]} stage in execute_code — each parallel step calls subagent_spawn with a different prompt, all running concurrently.
Environment injection is a front-end concern — Because the daemon is a long-running process separate from the front-end, any environment variable the session needs (e.g. SUPERPOWERD_SESSION_TOKEN) must be injected by the front-end via s/{id}/env. This is not a serious limitation, but it makes front-end setup slightly more involved: tools like superpowers require the front-end itself to be launched inside the privileged context (superpowers run-session ollie-tui ...), rather than simply having the variable present in the daemon's environment.
No MCP — MCP (Model Context Protocol) adds a JSON-RPC client, transport layer, initialization handshake, and subprocess lifecycle management to do what execute_code {tool: "name"} already does. Every MCP server can be replaced by a tool script in t/ and a skill in sk/. x/elevate proved this: it replaced an MCP server with a shell script. See doc/NO_MCP.md for the full justification.
AI pipelines with standard tools — ollie scripts compose into multi-stage AI pipelines via Unix pipes. Proof-of-concept:
; u/optimize -n 2 -cm qwen/qwen3-8b -jm 'anthropic/claude-opus-4.6' 'generate a hello world program. use c++.' >[2]/dev/null | b/q
u/optimize generates and judges candidate prompts, emitting the best to stdout; b/q acts on it. Any tool that reads stdin and writes stdout is already a pipeline stage.
Prompt composition — s/bfg outputs can be nested to arbitrary depth using shell command substitution. The inner prompt completes, its output becomes part of the outer prompt:
; echo 'translate to japanese: '`echo 'say hello' | s/bfg` | s/bfg
こんにちは！👋
This enables prompt pipelines where each stage transforms, filters, or augments the previous stage's output — all with standard shell syntax.