Wraps every AI tool.
Connects every source.
Any CLI agent on three data tracks — 5 verified, more in beta. One MCP hub for every agent. Linear / GitHub / Jira / GitLab issue import. HMAC-verified webhooks. Skills and automations that plug in without touching core.
Whatever you’re using, Operon wraps it
AdapterRegistry auto-detects installed CLI binaries. Each adapter picks the richest data track available: structured hooks when possible, PTY regex as a universal fallback. All tracks feed the same Trace model — so every instrument works on every agent.
Claude Code
Full hooks API via HookReceiver on 127.0.0.1:47777 — structured tool names, inputs, outputs, sub-agent IDs, session context. Richest data path, zero regex inference.
Cursor
Wraps Cursor's terminal in node-pty. ConversationAnalyzer strips ANSI codes, applies regex patterns, detects conversation boundaries. No Cursor-side config required.
Codex
PTY capture with stream JSON parsing when `codex --output-format stream-json` is available. Falls back to PTY regex for unstructured output.
Gemini CLI
PTY output regex analysis with idle-timeout trace completion (8s threshold). Per-tool health checks on session start.
Aider
PTY interception with simple-git diff integration for file change tracking. Auto-detects the `aider` binary and health-checks on every session start.
Plus droid, OpenCode, amp, goose, cline, and more — running in beta on the same adapter system.
Install once. Propagate everywhere.
Model Context Protocol servers extend any compatible agent with new tools. Operon’s MCP Hub means you install an MCP server in one place and Operon writes the right config into every agent profile on your machine.
Install once, propagate everywhere
Install MCP servers from Operon's MCP Hub. A per-adapter config writer writes the right configuration into every agent profile: Claude Code, Cursor, Gemini CLI, Aider. One place to manage, zero manual config files.
First-write confirmation
Before Operon touches any agent config file, it shows a diff of the exact changes with an explicit approve/reject dialog. You always see what we're writing and where.
Separate write token
The MCP Hub uses a write token distinct from the hook auth token. Revokable per-agent without losing hook telemetry.
Reusable prompts, bound to agents
Skill manifests package a prompt template, required tools, and a description into an installable unit. Install once in Operon, bind to any subset of your agents.
Skill manifests
Skills are installed via structured manifests with name, description, tools, and prompt template. SkillParser validates the manifest; SkillInstaller binds it into each agent profile.
Per-agent binding
A skill can be installed to one agent or many. Claude Code uses its own profile format; Cursor and Gemini get adapted writes. Remove a skill and Operon cleans up every profile it touched.
Full RPC CRUD
Install, list, enable, disable, remove — all via typed RPC with zod validation at the boundary. Settings UI wraps the router; CLI access is coming.
Marketplace (roadmap)
Browse and install community skills from a curated registry. Currently install-by-manifest only — marketplace is on the roadmap.
Seed sessions from real work
IssueImporter fans out to Linear, GitHub, Jira, and GitLab in parallel with per-source failure isolation. One picker, shared issue schema, no per-source UI. Every new session can start with full issue context baked in — acceptance criteria included.
Linear
Fetch issues by project, team, or cycle. Filter by state, priority, and assignee. IssuePicker in the New Session dialog seeds a session with full issue context: title, description, linked comments.
GitHub
GitHub issues API integration with label, milestone, and assignee filters. Same shared issue schema as Linear, Jira, and GitLab — one picker, four sources, no per-source UI.
Jira
Jira Cloud API with JQL query support. Epic and sprint awareness. Works alongside the other three sources — import from all of them in parallel via IssueImporter fan-out.
GitLab
Import issues, open merge requests, and post writeback comments — gitlab.com or a self-managed host. Same shared schema, same picker, no separate config.
Inbound triggers, cryptographically verified
WebhookReceiver sits on the HTTP layer and verifies HMAC signatures on every inbound webhook before it reaches the automation engine. Failed signature = 401 with explicit error, never silently dropped.
GitHub webhooks
HMAC-SHA256 signature verification on every inbound request. Failed signature = 401, no silent drops. Trigger automations from PR events, issue updates, CI completion, or any repository webhook.
Linear webhooks
Linear webhook verification with configurable secret. Per-team and per-workspace webhook endpoints. Subscribe to issue create, update, comment, and project events.
Jira webhooks
Jira Cloud webhook integration — issue events, sprint boundaries, workflow transitions. Shared verification pipeline with GitHub and Linear.
Schedules, triggers, and pluggable actions
AutomationEngine runs on cron or trigger events and dispatches to a pluggable ActionRegistry. Custom adapters hang off the registry — actions declare their inputs, outputs, and required scopes and Operon handles the rest.
Cron schedules
Schedule automations on cron expressions. Timezone-aware. Supports one-shot (`@once`) and recurring schedules with per-run dry-preview.
Template-based actions
AutomationEngine runs actions registered on ActionRegistry. Custom adapters plug in without modifying core — each action declares inputs, outputs, and required scopes.
Trigger-based firing
Beyond cron: webhook triggers (GitHub PR ready, Linear issue moved, CI failed), session lifecycle (session started, checkpoint rejected), and scheduled delays.
Per-automation audit
Last run, next run, status (ok / failed / dry-run), and result log. Filter by trigger source. Re-run with dry-run preview before production.
Starter catalog
Ten curated starter automations installable from Settings in one click: 'PR ready → run tests', 'failing CI → open task', 'stale branch → archive', and more — one per trigger/action pairing.
From session traces straight to PR body
Every session already captures the changes, decisions, and TODOs. PrDraftGenerator turns that into a PR body — grouped, summarized, and editable before you paste.
From traces to PR body
PrDraftGenerator walks the session trace tree and emits a heuristic PR body: files touched grouped by section, decisions extracted as a rationale block, TODOs surfaced as a follow-ups list.
Edit before copy
Generated body is shown in a full-screen editor before you copy. Rearrange sections, tweak tone, remove noise. Your PR, your voice.
Opens a real PR or MR
Not just copy-to-clipboard — PrLauncher opens the pull request on GitHub or the merge request on GitLab directly, with a status chip that follows it back to Operon.
Slots into your stack
AI tools, sources, webhooks, skills, automations. Nothing to replace — just instruments on top of what you already run.
Related reading
- The unified trace model behind every adapterOne shape for prompts, tool calls, and edits across five different agents.
- Persistent terminals for long agent runsWhy each session gets its own PTY that survives restarts and view changes.
- Run multiple AI coding agents in parallelIsolated Git worktrees and one Mission Control grid for every session.