Every instrument in your command center
Dozens of engines across six product pillars, all running in the Operon desktop app. Command a fleet, see everything it does, control the boundaries, remember every decision, wrap any agent, and keep the whole team on the same panel.
Command a fleet, not one session
Launch many agents in parallel, each in its own isolated worktree. Judge the same goal across several with Arena, coordinate them over a shared bus, and let Operon decompose the goal and route the work — worktrees and remote machines included.
Every active agent, one grid
Live fleet view across every session. A needs-attention queue surfaces what’s waiting on you first — oldest waiter, not loudest.
Same goal, N agents, one winner
2–4 agents work a goal in parallel, each isolated. Judged on cost, diff quality, files touched, and scope violations. You pick the winner; losers are reclaimed.
Agents talk to each other
Messages, a shared task DAG, and ask-human gates that surface directly in Mission Control — additive to orchestration, no shared state to reconcile.
Enter a goal. Get a plan.
Heuristic goal → subtask DAG based on keyword patterns (add / fix / refactor / migrate / test / document). Tool recommendations per subtask from your own historical success rate.
Plan lifecycle, end-to-end
Full plan lifecycle: create, start, pause, resume, cancel. Session linking, onSessionEnded advances subtasks, plan cards with progress bars.
Four modes, zero leakage
In-repo, new-worktree, pooled (warm pool), or remote (SSH). Pool warmth indicator in the New Session dialog. Default-preservation cleanup — worktrees don’t leak.
PTY over SSH, native UX
RemoteSessionBridge drops remote shell output into the same EventBus as local. Remote git over SSH, connection pool with DB-backed credentials.
Agents drive Operon from their own terminal
A second protocol socket lets any agent call Operon’s RPC — session status, traces, the coordination bus — straight from its own shell, no client chaining.
Line comments, sent as one prompt
Leave notes on the exact changed lines. Send focused feedback back to the running agent as one grouped prompt — no copy-paste round trip.
See every instrument, in real time
The credibility floor beneath the fleet. Everything your AI coding tool is doing, visible the moment it happens — no scrollback hunting, no black boxes, no after-the-fact forensics.
A live x-ray of the context window
Real-time token gauge, per-file relevance scores, and drop alerts the moment a critical file slips out of the context window.
A 0–100 judgment, not just a gauge
Named reasons (rot, thrash, compaction debt) with one-click fixes — compact now, or re-read the files that went stale underneath the agent.
Click an element, prompt the agent
Pick anything in the in-app preview — HTML, computed CSS, a cropped screenshot — and it becomes one grouped prompt to the running agent.
Every agent, every sub-process
Real-time agent tree for every spawned process, tool execution, and sub-agent task — with live CPU and memory readouts. Kill a runaway agent directly from the UI.
Set the goal. Track the thread.
AI-decomposed step breakdown from a single goal. Steps auto-complete from trace matching. Divergence detection flags plan drift.
Catch edit thrashing, search spirals, error cascades
Detects three failure patterns in real time, severity escalating on repeated triggers.
Your terminal, but it remembers
Daemon-backed PTY survives app restarts, view switches, and reboots. Snapshot-based attach restores any historical session state instantly.
Real-time spend, ground-truth or estimated
Per-model pricing, live cost gauge, and an explicit confidence badge distinguishing API-reported usage from heuristic estimates.
Step back through any session
Step-by-step playback of captured tool calls, diffs, and command output — scrubber, speed control (1x/2x/4x/8x), and code/conversation toggle. Share with a link; redaction controls included.
Searchable, filterable event stream
Trace-grouped timeline with category filters, sort toggles, and a properties panel for deep trace inspection.
Problems surface before they bite
Stuck developer detection, rabbit hole alerts, budget spikes, context collapse warnings — surfaced the moment patterns emerge.
Define the boundaries, gate the progress
Seeing isn’t enough. Define what the agent can touch, review every plan step before it continues, ship without leaving the app, and enforce team-wide rules — all at OS level, not by asking nicely.
Define allowed files and directories
If the agent goes off-limits, FSWatcher catches the write shortly after it lands. Operon reverts the file, pauses the PTY, and shows you the diff with approve or reject.
Review before the agent continues
Between plan steps, review all changes before the agent proceeds. Named git snapshots at each gate let you rollback with one click.
One declarative policy, hard enforcement
Protected paths, forbidden commands, budget ceilings, and a required test gate — merged from an org baseline down to a project override, with a full audit log.
Ship without leaving
Stage, hunk-stage, commit, push, open a PR or MR, merge to base — all in-app. No terminal required to get from review to shipped.
Real-time goal-drift detection
Continuous comparison between declared intent and observed activity. Heuristic checks fire the moment they diverge.
6-factor risk score on every checkpoint
File count, dependency depth, scope proximity, context pressure, historical success rate, and code complexity — scored at every gate before you approve.
Learn from recurring rejections
Auto-detects patterns in checkpoint rejections and scope violations, suggesting scope rules to prevent repeat mistakes.
Every step is a named git tag
Approve, reject, or rollback to any prior snapshot — full rollback without losing work on other sessions.
Every session makes the next one smarter
Decisions, patterns, failure modes, peak hours — built from your own sessions, not a generic model. The instruments adapt to how you actually work.
Why did it do that? Two clicks away.
Every decision links back to the prompt that caused it and what it superseded. Click any changed file, see the reasoning — auto-captured, searchable, tagged by confidence.
See how project memory evolves
Chronological memory view with superseded values. Understand what the project remembered, and when it changed its mind.
Detect contradictions, keep the audit trail
Jaccard-similarity detection surfaces memory conflicts in real time, with a full audit trail of every merge decision.
Generated on session end
Operon writes AGENTS.md to the repo with captured decisions, patterns, and project context, updating in place on later sessions.
Personal coding intelligence
Peak hours, tool preferences, plan abandonment, failure modes, context exhaustion rate — built from your sessions.
Know the risk before you start
Complexity assessment, risk signals, codebase alerts, and suggested steps — debounced as you type your goal.
Quality score + rewrite suggestions
Seven-rule analysis runs on your goal text. Badge + inline suggestions in the New Session dialog.
Historical matching for step outcomes
Matches the current step against traces from similar past steps — success probability, likely failure modes, estimated time.
Difficulty map, approach patterns, cost prediction
Per-directory difficulty map, approach fingerprinting, and cost prediction from keyword-similar past sessions.
Wrap any agent, connect any source
One adapter system for any CLI agent. One MCP hub for every agent profile. Skills, automations, webhooks, and issue imports — so Operon slots into the stack you already have.
Any CLI agent, 3 data tracks
Five verified adapters — Claude Code, Codex, Cursor, Gemini CLI, Aider — plus experimental support for droid, OpenCode, amp, goose, and cline behind a toggle. Hooks where supported, PTY regex everywhere else, one Trace model.
Install once, propagate everywhere
Install MCP servers from one place; Operon writes the right config into every agent profile. First-write confirmation before touching any config file.
Skill manifests, per-agent binding
Parse skill manifests, install into agent profiles, bind per-agent. Browse, install, and remove without leaving Operon.
Cmd+L, reusable prompts
Curated + your own prompts, searchable by tag, with a live quality badge. Send straight to the running agent’s terminal.
One click into your editor
Open any file an agent touched in VS Code, Cursor, Zed, or your JetBrains IDE — or reveal it in Finder.
Cron + templates + triggers
Runs on cron schedules or trigger events. Pluggable action registry, per-automation status, dry-run preview.
Inbound triggers from GitHub + Linear
Every inbound webhook signature-verified. Failed signature = 401, no silent drops.
Linear, GitHub, Jira, GitLab — one schema
Shared issue schema across four providers, per-source failure isolation. Seed a session with full issue context, acceptance criteria included.
From session traces to a real pull request
Files grouped by section, decisions → rationale, TODOs → follow-ups. Opens a real PR (GitHub) or MR (GitLab), not just a draft to copy.
“Agent needs you”, on your phone
Opt-in browser + phone push when a session goes awaiting-input, blocked, or errors — you don’t have to keep the tab open.
The whole team, on the same panel
Cost dashboards, best practice extraction, knowledge sharing, tool benchmarking, and client-ready reports — team-wide intelligence over the same trace data.
Cost, best practices, knowledge, benchmarks
Four dashboards: per-member cost with weekly trends, best practice extraction, knowledge sharing from hard directories, and per-tool benchmarking.
One click, a branded report
Your logo, your name, your footer line. A code-redaction mode strips diffs and tool output from the export so nothing code-shaped leaks into a client’s inbox.
The CFO-legible weekly
Per-member and per-project spend, top sessions, and a guardrails summary — emailed on a per-team cadence.
Did the AI’s changes stick?
Per-file snapshots at session end, cross-session churn detection over a 30-day lookback. Detects files AI edited that were later manually modified.
0–100 quality score per diff
Static analysis with 4 heuristic checks, wired into every completed trace.
Spend, trends, model breakdown
Per-session, per-project, per-developer attribution. Budget alerts with warning, critical, and exceeded thresholds.
Six categories, session + project level
Cost intelligence, productivity velocity, code impact heatmaps, session quality KPIs, tool usage distribution, smart alerts.
Project members, PM dashboard, client reports
Multi-tenant project membership with role scoping. PM dashboard with real-time team activity.
Full event stream for admins
Filterable by actor, resource, and time range — search, suspend/unsuspend, feature-flag toggles.
Outbox pattern, instant fan-out
Outbox-pattern push/pull, conflict resolution, and Supabase Realtime for instant team sync. RLS enforced on every cloud_* table.
One command center. Any agent.
Operon doesn’t pick winners. All instruments above work identically regardless of which agent you run. The adapter system routes data from any CLI into the same Trace model — via hooks where supported, PTY regex everywhere else.
Claude Code
Full hooks API — structured tool names, inputs, outputs, sub-agents, session context. Richest data path.
Cursor
PTY interception with regex patterns. Works with Cursor’s terminal without any config.
Codex
PTY + stream JSON parsing for structured output with —output-format stream-json.
Gemini CLI
PTY output regex analysis. ANSI-cleaned, idle-timeout trace completion.
Aider
PTY + git diff integration. Auto-detects binary, health-checked on session start.
Plus droid, OpenCode, amp, goose, cline, and more — experimental, behind a toggle in the New Session dialog.
Want to see the full adapter + integrations story? See /integrations. Or watch the fleet work end to end on /fleet.
Every instrument, on every session
Private beta — join the waitlist to get an invite when your slot opens up.
How these instruments work
- Real-time context window monitoringHow Operon tracks loaded and dropped files while an agent is running.
- AI coding cost tracking and budget intelligenceSpend by session, developer, and project, with spike detection and budgets.
- Extracting decision memory from AI sessionsHow architectural rationale is captured, tagged, and made searchable.