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

• Agent loop with streaming tool calls — the core runs a turn loop: prompt the model, parse tool calls, dispatch them (in parallel where safe), repeat until done
• Multi-backend routing — Ollama (local), OpenAI-compatible, Anthropic, GitHub Copilot, Kiro; switch backends per-session or let the tier router pick automatically
• Sandboxed tool execution — every tool call runs inside a Landlock sandbox with per-profile filesystem access rules
• Extensible tools — tools are executable scripts with header metadata; add one by dropping a file in a directory
• Multi-agent orchestration — orchestrator/worker patterns, subagent delegation, parallel fan-out — all coordinated through the session primitives
• Domain skills — teach the agent your project's conventions with a markdown file; loaded on demand
• Automatic context compaction — long conversations are summarized transparently when approaching the context limit
• Multiple frontends — terminal, acme, Emacs, KDE (plasmoid, standalone GUI, Kate plugin), and a browser-based web UI
• AI code completion — a completion endpoint that any editor can call via stdin/stdout

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