ollie

Ollie is an AI agent runtime. A small Go core handles the agent loop, tool dispatch, sandboxing, and multi-backend routing; frontends (terminal, acme, Emacs, KDE, browser) and orchestration (shell scripts, multi-agent workflows, cron) are external. The core is deliberately minimal — capabilities come from composing small pieces rather than building a monolithic framework.

Repository layout

Monorepo with Git submodules. Each submodule has its own Go module (except el which is Elisp and kde which is C++/Qt).

Directory	Language	Description
core/	Go	Core library: agent loop, backends, tools, config, sandbox
9p/	Go	9P filesystem server (olliesrv)
dbus/	Go	D-Bus session manager daemon (ollied)
acme/	Go	Plan 9 acme editor frontend
httpgw/	Go	HTTP-to-9P gateway (ollie-httpgw)
webui/	TypeScript	Preact SPA browser frontend
kde/	C++/Qt6	KDE integration: plasmoid, standalone GUI, Kate plugin, KRunner, tray
el/	Elisp	Emacs frontend (ellie.el)
agents/	JSON	Agent config files (loaded at runtime)
prompts/	Markdown	System prompt templates
tools/	Python/Bash	Tool scripts (file_read, lsp_, memory_, etc.)
scripts/	Shell	User-facing CLI scripts: session management, utilities, plumbing
sandbox/	YAML	Landlock sandbox config
doc/	Markdown	Architecture docs, usage guide
contrib/	Mixed	Community scripts
experiments/	Mixed	Trial notes

What you get

• Interactive AI shell — s/sh gives you a readline prompt that resumes your last session per directory, with streaming output and live model/backend switching
• One-shot queries that compose with Unix pipes — cat error.log | s/bfg "what caused this?" | s/bfg "suggest a fix"
• Parallel fan-out — s/bfg -parallel 4 spawns N agents on the same prompt and collects results
• Multi-agent workflows in plain shell — create named sessions, pass prompts between them via files, coordinate with statewait; no framework or SDK
• Subagent delegation — agents can fork ephemeral subagents that run independently and return results
• Tier-based routing — route dispatches subtasks to worker or expert models based on complexity; the orchestrator picks the tier, the system picks the backend/model
• Orchestrator/worker system — specialized agents for task decomposition (orchestrator) and scoped execution (worker/expert); workers read code and reason about implementation within their assigned scope
• Any model, any backend — Ollama (local), OpenAI, Anthropic, OpenRouter, GitHub Copilot, Kiro; switch per-session with one write
• Sandboxed execution — every tool call runs inside a Landlock sandbox with configurable filesystem access
• Extensible via plain scripts — drop executables into a directory and the agent picks them up; built-in tools cover file I/O, LSP (go-to-definition, references, rename, diagnostics), persistent memory, web search, and browser screenshots
• Domain skills — teach the agent your project's conventions with a markdown file; loaded on demand
• AI code completion — u/complete reads a prefix from stdin and prints the completion to stdout; plug it into any editor that can shell out
• Multiple frontends — terminal (s/sh), acme (ollie-acme + Kmpl), Emacs (ellie), KDE (plasmoid, standalone GUI, Kate plugin), and a browser-based web UI; all talk to the same 9P server
• Remote access — mount a remote server's namespace locally with 9pfuse, or use the HTTP gateway with curl or the web UI
• Store federation — point tools or transcripts at a remote 9P mount to share across machines
• Prompt optimization — u/optimize generates N candidate prompts in parallel, then judges them to return the best one
• Automatic context compaction — long conversations are summarized transparently when approaching the model's context limit
• Per-agent 9P principals — each agent session mounts the filesystem as its own user; 9P permission enforcement prevents self-prompting loops and enforces access boundaries

Getting started

Clone with submodules:

git clone --recurse-submodules https://github.com/lneely/ollie.git

Or after cloning:

git submodule update --init --recursive

Build and install everything from the monorepo root:

mk

Or build specific components:

mk core    # Core library
mk 9p      # 9P filesystem server
mk httpgw  # HTTP gateway
mk webui   # Web UI (requires Node.js + npm)
mk dbus    # D-Bus daemon
mk data    # Install agents/prompts/tools/skills to ~/.config/ollie/
mk scripts # Install CLI scripts

For KDE, build from kde/ with CMake. For Emacs, copy el/ellie.el into your config and (require 'ellie).

See doc/USAGE.md for usage instructions.

Configuration

Environment: ~/.config/ollie/env

OLLIE_BACKEND=openai           # ollama | openai | anthropic | copilot | kiro (default: ollama)
OLLIE_OLLAMA_URL=              # base URL for Ollama (default: http://localhost:11434)
OLLIE_OPENAI_URL=https://openrouter.ai/api
OLLIE_OPENAI_KEY=sk-or-...
OLLIE_ANTHROPIC_KEY=sk-ant-...
OLLIE_COPILOT_TOKEN=...
OLLIE_KIRO_TOKEN=...           # bearer token or sqlite:// path (auto-detected from Kiro CLI if unset)
OLLIE_MODEL=qwen/qwen3-235b-a22b
OLLIE_TOOLS_PATH=~/.config/ollie/tools    # directory for tool scripts ({tool} steps)
OLLIE_MEMORY_PATH=~/.config/ollie/memory  # directory for memory files (ollie/m)
OLLIE_ELEVATE_SOCKET=${XDG_RUNTIME_DIR}/ollie/elevate.sock  # socket path for x/elevate adapter
OLLIE_COMPLETE_BACKEND=ollama             # backend for u/complete (required)
OLLIE_COMPLETE_MODEL=qwen3:latest         # model for u/complete (required)
OLLIE_ENABLED_BACKENDS=openrouter,kiro  # backends available for routing (comma-separated)

# Per-backend tier models for t/route
OLLIE_TIER_WORKER_openrouter=mistralai/devstral-small
OLLIE_TIER_EXPERT_openrouter=anthropic/claude-sonnet-4-20250514
OLLIE_TIER_WORKER_kiro=claude-haiku-4-20250514
OLLIE_TIER_EXPERT_kiro=claude-sonnet-4-20250514
OLLIE_TIER_WORKER_anthropic=claude-haiku-4-20250514
OLLIE_TIER_EXPERT_anthropic=claude-sonnet-4-20250514
OLLIE_TIER_WORKER_ollama=qwen3:8b
OLLIE_TIER_EXPERT_ollama=qwen3:32b

Shell environment variables take precedence over the env file.

Development

Update all submodules to latest:

git submodule update --remote

Each submodule has its own Go module with independent tests (go test ./...). See individual submodule READMEs for component-specific build and test instructions.

Credits

Many sources of inspiration:

• Plan 9 from Bell Labs — for an interesting system
• @9fans — for the Plan 9 port
• Suckless — for articulating good software development principles
• @simonfxr — for a solid agent baseline to "borrow" from, and other nifty ideas
• @aws — for a solid open-source agent implementation

License

GPLv3