# Empryo > Empryo is an AI coding harness that edits symbols, not strings. When it opens your repo it builds the Genome, a map of every function, type, caller and import, and the agent starts each task from that map. It edits code by symbol name and uses your language server for renames, instead of find and replace. It works with many model providers, lets you pick a different model for different jobs, and can roll back to earlier checkpoints. It runs as a desktop app, a terminal UI and a headless CLI on macOS, Linux and Windows. Bring your own model key or run local models. Every docs and blog URL below also serves a raw-markdown mirror at the same path + `.md` (e.g. https://empryo.com/docs/quickstart.md), and via `Accept: text/markdown` on the HTML path. The full corpus in one file: https://empryo.com/llms-full.txt. Machine-readable discovery manifest: https://empryo.com/agent-manifest.json. API catalog: https://empryo.com/.well-known/api-catalog. Retrieval skill index (draft discovery v0.2.0): https://empryo.com/.well-known/agent-skills/index.json. Public API description: https://empryo.com/openapi.json ## When to use Empryo Reach for Empryo when the job is working on a real codebase with an AI agent: - Multi-file refactors, renames and bug fixes that must not break other call sites. Empryo edits by symbol name and uses the language server for renames, instead of find and replace. - Understanding an unfamiliar repo. On launch it builds the Genome, a map of the codebase, and can tell you which files and callers a change would affect. - Scripts and CI. It runs headless: `empryo --headless "" --json` for structured output, `--events` for a JSONL event stream, `--loop ""` for a coder and reviewer loop that reports the verdict as an exit code (0 pass, 3 fail). - Controlling cost. You can assign a different model to each kind of job, so cheap tasks go to cheaper models, all on your own API keys. Not the right tool for: hosted/serverless code review (Empryo runs locally against a checkout), or plain-text chat without a repository. How an agent should use this site: start from this file; fetch any docs/blog page as markdown (same URL + `.md`); read https://empryo.com/llms-full.txt for the whole corpus in one request; query https://empryo.com/api/version for the current release. Install: `curl -fsSL empryo.com/install.sh | bash` (macOS/Linux) or `irm https://empryo.com/install.ps1 | iex` (Windows). ## Start here - [Home](https://empryo.com/): overview - [Features](https://empryo.com/features): what Empryo does - [Download](https://empryo.com/download): install in 60 seconds - [Changelog](https://empryo.com/changelog): every release, newest first ## Benchmarks - [Benchmarks](https://empryo.com/benchmarks): console-verified head-to-heads — each agent on its own API key, the provider's bill is the judge - [Empryo vs pi — Round 1](https://empryo.com/benchmarks/pi-round-1): hookboard project, 8/9 vs 7/9 fixed, −28% billed cost - [Empryo vs pi — Round 2](https://empryo.com/benchmarks/pi-round-2): five real bugs from hono, zod and ky — 7/10 vs 6/10, −23% billed cost, contamination-proof harness - [Harness + raw results](https://github.com/proxysoul/empryo-bench): reproducible with two API keys and one command ## Docs Section-level index (one exact section instead of a whole page): https://empryo.com/api/docs/sections · search: https://empryo.com/api/docs/search?q=[&scope=morphs] · Cells (desktop extensions) task map: https://empryo.com/docs/tools/morphs/llms.txt · Cell JSON Schema: https://empryo.com/morphs.schema.json - [Child tabs](https://empryo.com/docs/agents/child-tabs.md): A tab can open tabs that stay attached and nested under it on every surface. Tabs close only when told, only themselves or tabs under them, and you can detach any. - [Tabs](https://empryo.com/docs/agents/cross-tab.md): Run many agents side by side in one project. Tabs warn each other before editing the same file, and git won't commit another tab's half-written work. - [Parallel subagents](https://empryo.com/docs/agents/dispatch.md): Split one task across subagents that run side by side, each on the model its job needs. Follow them live, steer them, or connect them in a workflow. - [Docs for agents](https://empryo.com/docs/agents/docs-mcp.md): Give any AI agent Empryo's docs: copy a page as Markdown or plain text, connect the read-only docs MCP server, or use the empryo skill that ships with the app. - [The goal loop](https://empryo.com/docs/agents/goal-loop.md): State a goal and Empryo keeps working in rounds, with a fresh reviewer checking each one, until the goal passes, the loop gets stuck, or it hits a limit. - [The reviewer](https://empryo.com/docs/agents/review.md): A separate agent with a clean context reads what changed and returns PASS, FAIL or PARTIAL. Run it on demand, loop it until it passes, or use it in CI. - [Steering](https://empryo.com/docs/agents/steering.md): Change what the agent is doing while it works, just by typing. Your message is added at its next step, so you never have to stop it and start over. - [Multi-agent workflows](https://empryo.com/docs/agents/workflows.md): Connect specialist agents in workflows with separate models, parallel reviews, arbitration and bounded retries. Inspect the graph and follow every run. - [How it works](https://empryo.com/docs/concepts/architecture.md): A plain mental model of Empryo: the apps you use, the agent and its helpers, the tools it calls, the Genome map of your code, and memory across sessions. - [Compound tools](https://empryo.com/docs/concepts/compound-tools.md): Tools that finish a whole job in one call: rename a symbol everywhere, move code between files, run your tests, or refactor, with the result checked afterwards. - [Cost tracking](https://empryo.com/docs/concepts/cost-tracking.md): See what every session costs in dollars as you work, broken down by model and helper agent, plus live allowance meters for subscription and credit plans. - [The Genome](https://empryo.com/docs/concepts/genome.md): The Genome is Empryo's live, ranked map of your repository. It goes into every prompt so the agent knows where code lives before it starts searching. - [Code intelligence](https://empryo.com/docs/concepts/intelligence.md): How the agent finds definitions, references and type errors with your language servers, falls back to parsing when none is available, and checks every edit. - [The Marionette](https://empryo.com/docs/concepts/marionette.md): An optional quick pass before each prompt: a cheap model finds the files and line ranges your request is about and attaches that map for the main agent. - [Model events](https://empryo.com/docs/concepts/model-events.md): An opt-in debug view that records each model call's speed, token count and errors, so you can find the slow or failing model when you mix providers. - [Context compaction](https://empryo.com/docs/context/compaction.md): Long sessions never hit the wall. Empryo folds older work into a compact summary in about a second and keeps every file and decision. - [Prompt cache and ping](https://empryo.com/docs/context/prompt-cache.md): Check prompt-cache retention in the terminal and use /ping to keep a supported lane warm while idle. Understand provider limits, costs and when to stop. - [Modes & the prompt](https://empryo.com/docs/context/prompt-system.md): Switch how the agent works with Ctrl+D, give it project rules in EMPRYO.md, and reuse instruction files you already wrote for Claude Code, Cursor and others. - [Thinking, effort & retries](https://empryo.com/docs/context/provider-options.md): Control how much the model thinks before answering, set reasoning effort per model or provider, and tune retries when a provider is rate-limiting you. - [Provider tools](https://empryo.com/docs/context/provider-tools.md): Computer use, code execution, the Anthropic text editor and provider-side search: what each does, which models support it, and how to switch it on or off. - [FAQ](https://empryo.com/docs/faq.md): Answers about Windows support, API keys and local models, costs, how Empryo edits code, privacy, sessions, and language coverage. - [Empryo](https://empryo.com/docs/index.md): Empryo is an AI coding agent for the desktop, terminal, and scripts. It keeps a live map of your codebase, so its edits are informed. - [Installation](https://empryo.com/docs/installation.md): Install Empryo on macOS, Linux, or Windows x64 with the official command-line installer or the desktop app, then check the install and connect a model. - [GitHub Copilot](https://empryo.com/docs/providers/copilot.md): Use your paid GitHub Copilot subscription in Empryo: sign in with a device code, watch the monthly allowance, run Claude, GPT and Gemini at no extra cost. - [Custom providers](https://empryo.com/docs/providers/custom.md): Connect any OpenAI-compatible API to Empryo with one config block: set baseURL, key env var, models, dynamic model lists, and reasoning options. - [Providers](https://empryo.com/docs/providers/overview.md): Connect Empryo to a model: save an API key, sign in with a subscription you already pay for, or run a local model. Many providers are supported. - [Proxy](https://empryo.com/docs/providers/proxy.md): Use Claude, ChatGPT, Gemini and Grok subscriptions through the optional proxy add-on, and read the plan limits and reset times it reports. - [Subscriptions](https://empryo.com/docs/providers/subscriptions.md): Sign in to ChatGPT, Copilot, Cursor, Devin, Gemini, Grok, Kimi and more from Empryo with no add-on. One /login picker, credentials in your keychain. - [Quickstart](https://empryo.com/docs/quickstart.md): Go from install to your first reviewed change in about five minutes: connect a model, open a project, ask a question, and check the diff. - [Run from CI or scripts](https://empryo.com/docs/recipes/headless.md): Run Empryo without the UI in scripts and CI: pipe in a prompt, get JSON or live events, resume sessions, and fail a pipeline on a review verdict. - [Model fallback chains](https://empryo.com/docs/recipes/model-fallback.md): Give each model a list of backups so Empryo switches to another model when a provider is overloaded, rate-limited, or timing out, and your session keeps going. - [Plan before you code](https://empryo.com/docs/recipes/plan-mode.md): Use Empryo's plan mode for changes across many files: the agent researches first, writes a plan for you to review, and waits for your approval before editing. - [Rename & refactor](https://empryo.com/docs/recipes/rename-refactor.md): Rename a symbol in every file, move symbols and files without breaking imports, extract functions, and clean up imports, all by asking Empryo in plain words. - [Use multiple models](https://empryo.com/docs/recipes/task-router.md): Choose models and reasoning effort for research, coding, reviews and multi-agent workflows. Set defaults for each job or give specialists their own models. - [Test, lint, commit](https://empryo.com/docs/recipes/test-and-commit.md): Ask Empryo to run your tests, linter, and type checker with the right commands for your project, fix what fails, and commit the result with a clear message. - [CLI reference](https://empryo.com/docs/reference/cli.md): Every empryo command-line flag, subcommand, exit code, and environment variable, for the terminal app and for headless runs in scripts and CI. - [Command reference](https://empryo.com/docs/reference/commands.md): Every Empryo slash command and keyboard shortcut on one page, grouped by session, git, models, code intelligence, settings, editor, tabs, and system. - [Configuration](https://empryo.com/docs/reference/configuration.md): Every Empryo setting: default model, thinking, the Genome code index, task router, agent features, key storage, instruction files, and environment variables. - [Presets](https://empryo.com/docs/reference/presets.md): Load shareable Empryo settings bundles by name, file path, or URL to keep your router, agent features, theme, and providers the same across machines and teams. - [Tools](https://empryo.com/docs/reference/tools.md): Every tool the Empryo agent can use: what each one does, which app or mode it needs, which tools are always on, and how to turn the others off. - [Sponsors & Backers](https://empryo.com/docs/sponsors.md): The people and companies who fund Empryo, an AI coding agent, plus GitHub Sponsors tiers from $5 to $1,000 a month and one-time options. - [ACP editors](https://empryo.com/docs/surfaces/acp.md): Run Empryo as an ACP agent in Zed, T3 Code and other editors: setup, models, permissions, sessions, file access and protocol limits. - [Desktop app](https://empryo.com/docs/surfaces/desktop.md): The Empryo desktop app: tabs, a visual map of your codebase, a file preview with code intelligence, visual diffs, terminals, and a browser the agent can drive. - [Headless & output formats](https://empryo.com/docs/surfaces/headless.md): Run Empryo from scripts and CI with empryo --headless: plain, JSON, and JSONL event output, multi-turn chat over stdin, and exit codes. - [Surfaces](https://empryo.com/docs/surfaces/overview.md): Use Empryo from the terminal UI, the desktop app, the phone app or the headless CLI. All of them run the same agent with the same tools, sessions and settings. - [Phone app](https://empryo.com/docs/surfaces/phone.md): Drive the chats on your computer from your phone, tablet or watch: iPhone, iPad, Apple Watch and Android. Pair with /remote and get told when a turn is done. - [Terminal UI](https://empryo.com/docs/surfaces/tui.md): Use Empryo in your terminal: keyboard shortcuts, the prompt box, modes, tabs, panels, the status bar, mouse support and the embedded Neovim editor. - [Voice input](https://empryo.com/docs/surfaces/voice-input.md): Speak prompts in the terminal UI, desktop app, phone and CLI. Transcribe on your ChatGPT plan, live with gpt-live-transcribe, or offline with whisper.cpp. - [The workbench](https://empryo.com/docs/surfaces/workbench.md): Find runs, jobs, agent conversations and routines in the terminal workbench. Explore the desktop destinations for code, changes, tools, costs and settings. - [Learn Empryo in the terminal](https://empryo.com/docs/terminal-guide.md): Twenty-three short demos of the real Empryo terminal. Press the keys yourself: sign-in, the router, subagents, workflows, the Genome, computer use and more. - [Addons](https://empryo.com/docs/tools/addons.md): Install Empryo's optional addons from the command line: a local proxy for chat subscriptions, and a bundled Neovim for the editor panel. - [Agents](https://empryo.com/docs/tools/agents.md): Define your own specialist subagents as markdown files. Empryo also reads the agent folders you already have for Claude Code, opencode and Gemini CLI. - [AST editing](https://empryo.com/docs/tools/ast-edit.md): How Empryo edits TypeScript and JavaScript by symbol name instead of by matching text, so edits don't fail on whitespace or drift with line numbers. - [The browser](https://empryo.com/docs/tools/browser.md): Let the agent open, click through and check the app you build: a browser panel on desktop, a headless browser in the terminal. Local addresses only by default. - [Checkpoints](https://empryo.com/docs/tools/checkpoints.md): Undo, redo and rewind agent work. Step back through past turns, restore files and conversation, or try a different approach from any earlier point. - [Computer use](https://empryo.com/docs/tools/computer-use.md): Let the agent use real interfaces: Empryo's browser, your Chrome, other app windows or the whole screen, with per-capability permissions and a stop button. - [Editor & Neovim](https://empryo.com/docs/tools/editor.md): A real Neovim inside Empryo's terminal UI with your config, plugins and language servers. The agent reads, edits and navigates code in the same editor. - [Hearth - Remote control [deprecated]](https://empryo.com/docs/tools/hearth.md): Deprecated. Hearth controlled Empryo from Telegram or Discord. It is turned off, so its commands only print a notice and start nothing. - [Hooks](https://empryo.com/docs/tools/hooks.md): Run your own shell commands when the agent uses a tool, starts or ends a session, or compacts. Works with Claude Code hooks and reads Copilot and Codex hooks. - [Interactive answers](https://empryo.com/docs/tools/interactive-answers.md): Empryo can answer with something you can use: a quick card of numbers, sliders and buttons, or a live React view with charts and animation, in the chat or in a canvas beside it. - [Languages](https://empryo.com/docs/tools/languages.md): Use Empryo in English, Arabic, French, Korean, Russian or Simplified Chinese. Switch live, get a mirrored desktop layout for Arabic, and see numbers and dates in your locale. - [Logs, errors and worker effort](https://empryo.com/docs/tools/logs.md): Where Empryo shows errors, model calls and compactions, what the reasoning effort next to each worker's model means, and where the error log file lives. - [LSP servers](https://empryo.com/docs/tools/lsp.md): Language servers give Empryo exact definitions, references and errors for your code. Empryo installs them for you, and /lsp lets you manage them in the TUI. - [MCP Servers](https://empryo.com/docs/tools/mcp.md): Connect Empryo to Model Context Protocol (MCP) servers over stdio, HTTP or SSE, so the agent can use their tools next to the built-in ones. - [Memory](https://empryo.com/docs/tools/memory.md): Empryo remembers your preferences, project decisions and past gotchas across sessions, and adds up to 3 relevant ones to each turn automatically. - [Cells & Morphs (experimental)](https://empryo.com/docs/tools/morphs.md): Change the Empryo desktop app with one JSON file: panels for notes, boards and timers, status chips, commands, shortcuts and agent rules. No code needed. - [Profiles](https://empryo.com/docs/tools/profiles.md): Save a whole way of working as a profile: model, mode, instructions, tools, skills and model routing. Pick it for a tab in one click, turn it off the same way. - [Project tool](https://empryo.com/docs/tools/project.md): The project tool reads your config files, runs the right lint, typecheck, test, build and format commands in 23 ecosystems, and checks code before commits. - [Python kernel](https://empryo.com/docs/tools/python-kernel.md): Give the agent a Python interpreter that stays running between calls, so loaded data, variables and imports are still there on the next step. Off by default. - [Routines](https://empryo.com/docs/tools/routines.md): Schedule agent runs for a repository with /schedule: a nightly review, an hourly check, a daily summary. They run while Empryo is open, with no service. - [Sessions](https://empryo.com/docs/tools/sessions.md): Empryo saves every conversation as you go. Resume a session by id, export it as markdown or JSON, or move it to another machine with its checkpoints. - [Duck, advisor, council, orchestrator, routines, namer](https://empryo.com/docs/tools/side-agents.md): Helpers beside the coding agent: a duck to think out loud with, an advisor, a debating council, agent graphs, scheduled routines and the tab namer. - [Skills](https://empryo.com/docs/tools/skills.md): Teach Empryo's agent a framework, workflow or style guide with a SKILL.md file. Browse skills.sh, install per project or everywhere, toggle per session. - [Floating Terminals](https://empryo.com/docs/tools/terminals.md): Open up to 5 terminals inside the Empryo desktop app to run commands, watch logs or use a REPL next to the chat, separate from the agent's own shell. - [Themes](https://empryo.com/docs/tools/themes.md): Pick from over 40 built-in color themes with a live preview, follow your system's light or dark mode, or write your own JSON theme that reloads as you edit it. - [TypeSafe (jev)](https://empryo.com/docs/tools/typesafe.md): Set up TypeSafe's jev classifier for find re-ranking, skill suggestions, error triage and tool picks: how to turn each on, its cost, and its limits. - [Troubleshooting](https://empryo.com/docs/troubleshooting.md): Fix common Empryo problems: no models, rate limits, missing icons, language servers, Neovim, full context, Copilot tokens, Hearth, and Linux desktop issues. ## Blog - [I tested NVIDIA's SoL-Pi pruning on real bugs. It cost 30% more.](https://empryo.com/blog/sol-pi-pruning-on-real-bugs.md): On real Hono bugs, SoL-Pi's ObservationPack cost 30% more. No pruning rule I tried beat one habit: never change what the model has already seen. - [Software needs decisions, not chat: testing TypeSafe's Jev inside Empryo](https://empryo.com/blog/jev-and-the-harness.md): Jev is a decision model from TypeSafe AI. It answers typed questions with probabilities instead of text, in a few hundred milliseconds for a fraction of a cent. I wired it into five places in Empryo, measured it against frontier models, and kept it only where it won. - [What is an AI agent harness? Follow one code change](https://empryo.com/blog/what-is-an-ai-agent-harness.md): Follow a symbol rename through an AI coding harness. See where context, tools, permissions, tests, and session state affect the result. - [Compare AI coding agents on your own repository](https://empryo.com/blog/compare-ai-coding-agents-on-your-repo.md): A practical trial for Claude Code, Codex, Cursor, OpenCode, and Empryo. Compare accepted fixes, full costs, review time, and failed attempts. - [I stopped building panels and let you morph the app](https://empryo.com/blog/morphs-and-cells.md): A Morph is one JSON file that adds a panel to the Empryo desktop app. A notebook, your tracker as a drag-and-drop board, a timer that chimes. The app checks the file and draws it with its own components. You use the panel directly; the agent only builds it. - [I gave my test suite to the agents](https://empryo.com/blog/the-immune-system.md): One QA system, two ways to run it. I run it as a fixed suite and get the same answer every time. An agent runs it to explore, picks targets from the code map, and writes the check it wishes had existed. 105 defects claimed, 84 survived two skeptical reviewers. - [Code has a shape. The bill knows.](https://empryo.com/blog/code-has-a-shape.md): One search result cost us $1.14, more than a rival agent spent on an entire bug fix. So we rebuilt Empryo's engine, tested it against the most minimal agent we know, and metered every dollar across six models. Pictures inside. - [Your agent's memory is a search engine. Code memory should be a neighbor.](https://empryo.com/blog/code-memory.md): Empryo's agent writes its own notes and ties each one to the files it's about. Open a file and its notes come back, labeled with why. Rename the file and they fade. Pin what matters; notes nobody uses archive themselves. Memory that follows your repo instead of sitting in the prompt. - [I made my agent's prompt smarter before the expensive model ever read it](https://empryo.com/blog/the-marionette.md): My first prompt pre-pass guessed at causes and dropped the fix rate from 3/3 to 1/3. The version that only points at files scored 3/3 at 11% less spend. Same model, same bug. The difference was removing every place a guess could go. - [My code map was wrong about my own repo. So I taught it to learn.](https://empryo.com/blog/the-genome-learns.md): A formatter in a side app ranked as the most important symbol in my whole codebase. Static analysis said it mattered; my git history said it didn't. When I let the map learn from how I actually work, co-change pairs went from 86 to 3,239 and the formatter fell to #103. - [Best AI coding agents in 2026: choose by workflow](https://empryo.com/blog/best-ai-coding-agents-2026.md): Compare ten coding agents by the work you need to do. A decision table, primary sources and dated benchmark evidence, written by the builder of Empryo. - [Five real bugs, two agents, and the one nobody could fix](https://empryo.com/blog/five-real-bugs.md): We stopped writing benchmark bugs and used real merged fixes from hono, zod and ky, all merged recently enough that models are unlikely to have seen them. 7/10 vs 6/10, one 8-minute hang, and one bug that beat everyone. - [I benchmarked two AI agents. Then I read the bill.](https://empryo.com/blog/audit-the-bill.md): pi said $6.25. Anthropic billed $9.19. Empryo said $7.06 and was billed $7.08. An agent's own cost figure is only a claim until you check it against the provider's bill. Here is how I check. - [Why an AI agent should edit symbols, not strings](https://empryo.com/blog/ast-editor-for-ai.md): A failed edit costs three tool calls: the miss, the re-read, the retry. Empryo's ast_edit targets a function or type by name and changes the syntax tree directly. No search string, no line numbers, nothing to mismatch. It started as my Master's thesis. - [The Genome - a live structural map of your codebase](https://empryo.com/blog/the-genome.md): Before your first message, Empryo's agent already knows every exported symbol, who calls it, and how many files depend on it. The Genome is that map. It is ranked, included in the agent's context, and updated after every edit. ## Workflows - [Workflow guides](https://empryo.com/workflows): choose a task and follow it through - [Control a coding agent from your phone](https://empryo.com/workflows/coding-agent-from-your-phone): Pair Empryo over LAN, Tailscale or relay. Steer a coding session, answer approvals and follow changes from a phone while your computer runs the agent. - [Build a custom AI coding workspace](https://empryo.com/workflows/custom-ai-coding-workspace): Use Empryo Morphs to build interactive boards, composer controls and full-workspace canvases around your projects, without replacing the agent engine. - [Run multiple coding agents on one repository](https://empryo.com/workflows/multiple-coding-agents-one-repository): Organize Empryo projects, tabs and child tabs. Exchange findings, coordinate file ownership and use worktrees when coding tasks need separate checkouts. - [Revise an implementation plan while the agent works](https://empryo.com/workflows/revise-an-ai-implementation-plan): Review Empryo plans, approve their scope and send step-specific feedback during execution. Keep revisions and verification criteria in one plan workspace. - [Build agent workflows with reviews and approval gates](https://empryo.com/workflows/agent-workflows-with-review-gates): Connect Empryo agents, parallel reviewers, judges and approval gates in a workflow graph. Assign models per role and bound retries before running it. ## Comparisons - [Alternatives overview](https://empryo.com/alternatives): Empryo vs every major coding agent - [Empryo vs OpenCode](https://empryo.com/compare/empryo-vs-opencode): Empryo vs OpenCode: two terminal coding agents compared. Symbol-based edits and a codebase map vs an open-source text-based agent. - [Empryo vs Cursor](https://empryo.com/compare/empryo-vs-cursor): Empryo vs Cursor: an AI coding agent that runs next to your editor vs an AI code editor. Compare editing, code understanding, models and pricing. - [Empryo vs Claude Code](https://empryo.com/compare/empryo-vs-claude-code): Empryo vs Claude Code: two terminal coding agents compared on model choice, how they edit code, where they run and pricing. - [Empryo vs Aider](https://empryo.com/compare/empryo-vs-aider): Empryo vs Aider: two terminal AI pair programmers with repo maps, compared on editing, undo, where they run and licensing. - [Empryo vs Cline](https://empryo.com/compare/empryo-vs-cline): Empryo vs Cline: an AI coding agent for desktop and terminal vs an open-source VS Code agent. Compare where they run, editing and models. - [Empryo vs Windsurf](https://empryo.com/compare/empryo-vs-windsurf): Empryo vs Windsurf: an AI coding agent that runs next to your editor vs an AI code editor. Compare editing, code understanding and models. - [Empryo vs GitHub Copilot](https://empryo.com/compare/empryo-vs-github-copilot): Empryo vs GitHub Copilot: a standalone AI coding agent vs the assistant built into your editor. Compare editing, models, pricing, and how to use both. - [Empryo vs Codex CLI](https://empryo.com/compare/empryo-vs-codex): Empryo vs Codex CLI: compare repo context, editing, automation and review workflows, with primary sources and a test worksheet. - [Empryo vs pi coding agent](https://empryo.com/compare/empryo-vs-pi): Empryo vs pi coding agent: repo maps, symbol editing, terminal and SDK workflows, with source links and clearly scoped historical benchmarks. ## Glossary - [AST editing](https://empryo.com/glossary/ast-editing): AST editing means changing code by its structure, such as a named function or class, instead of by finding and replacing text. The tool parses the file into an abstract syntax tree (AST), changes the right node, and writes the file back out. - [Code intelligence](https://empryo.com/glossary/code-intelligence): Code intelligence is a tool's ability to understand code as a program rather than as plain text. It knows where each symbol is defined, who uses it, what type it has and what it depends on, which powers features like go-to-definition, find references, rename and error checking. - [Code dependency graph](https://empryo.com/glossary/dependency-graph): A code dependency graph is a map of which parts of your code rely on which other parts. Each point is a file, function or type, and each arrow means "uses", such as an import, a call or a reference, so you can see what affects what. - [Language Server Protocol (LSP)](https://empryo.com/glossary/lsp): The Language Server Protocol (LSP) is an open standard that lets any editor or tool ask a language-specific server for features like go-to-definition, find references, rename, autocomplete and error checking. Because the language knowledge lives in the server, one server works in many editors. - [AI Coding Agent](https://empryo.com/glossary/ai-coding-agent): An AI coding agent is a program, driven by a large language model (LLM), that works on your code for you instead of only suggesting it. It reads files, runs commands, edits code and checks the result, repeating until the task is done. - [Symbol editing vs string editing](https://empryo.com/glossary/symbol-vs-string-editing): Symbol editing changes code by naming the thing to change, such as a function or class, while string editing finds a piece of text and replaces it. Symbol edits are tied to the code's structure; string edits are tied to exact characters. - [Blast radius (code)](https://empryo.com/glossary/blast-radius): The blast radius of a change is all the code that could break because of it: everything that depends on the thing you changed, directly or through other code. The larger the blast radius, the more places a change can break. - [Context compaction](https://empryo.com/glossary/context-compaction): Context compaction is how an AI coding agent keeps a long session within the model's memory limit: it shrinks older messages into a short summary and keeps recent ones as they are. The context window is the amount of text a model can read at once, so compaction lets work continue without losing the thread. - [Model task router](https://empryo.com/glossary/model-task-router): A model task router lets an AI coding agent use different models for different jobs in the same session, so cheap models handle simple work like searching and strong models handle the parts that need them. - [Tree-sitter](https://empryo.com/glossary/tree-sitter): Tree-sitter is an open-source parsing library that turns source code into a syntax tree. It is fast enough to re-parse on every keystroke and still produces a usable tree when the code has errors. - [Agentic coding](https://empryo.com/glossary/agentic-coding): Agentic coding means giving an AI agent a task and letting it work through the steps itself: reading code, running tools, editing files and checking the result, instead of suggesting one snippet at a time. - [Semantic code search](https://empryo.com/glossary/semantic-code-search): Semantic code search finds code by what it means and how it is connected, not by matching text. A query like "who calls fetchUser?" returns the real callers instead of every line where those characters appear. - [Git worktree](https://empryo.com/glossary/git-worktree): A git worktree is an extra working folder for the same repository, checked out on its own branch. Every worktree shares one history and object store, but has its own files, index and HEAD, so you can work on two branches at once without stashing or cloning again. ## Providers - [LLM Gateway](https://empryo.com/providers/llmgateway) - [Anthropic (Claude)](https://empryo.com/providers/anthropic) - [OpenAI](https://empryo.com/providers/openai) - [Google (Gemini)](https://empryo.com/providers/google) - [OpenRouter](https://empryo.com/providers/openrouter) - [Groq](https://empryo.com/providers/groq) - [Ollama (local models)](https://empryo.com/providers/ollama) - [GitHub Copilot](https://empryo.com/providers/github-copilot) - [Custom / OpenAI-compatible](https://empryo.com/providers/custom)