Ingot 推出可逐項審核 AI 修改的桌面 IDE beta
No more VS Code: introducing Ingot, the AI IDE where you review every edit
Ingot 推出適用於 macOS、Windows 和 Linux 的桌面 AI IDE beta,AI 智能體的修改會以可逐項接受或拒絕的程式碼區塊呈現,確認前不會寫入檔案。編輯器免費,AI 功能每月 $15 起;正文亦區分 beta 現有、仍在建置及即將推出的功能。
A lot of us spent years in VS Code. It became the default: a solid editor, a huge extension ecosystem, and a layout everyone's hands already knew. Then coding agents arrived, and that default started to feel like a chat panel taped onto an editor built for typing every line yourself.
The job changed. The agent can plan, edit across files, run tests, and keep going. What didn't change, in most setups, is the review step. You still get a monologue — "I fixed the null check and added a test" — and a diff that is often larger than that sentence. The null check is in there. So is a helper renamed "for clarity," a slightly weaker assertion, and a format pass on a file the agent only passed through.
We built Ingot around a different default. The agent works in your project. Every change lands as hunks you accept or reject, in the chat or right in the editor. Nothing is written to disk until you say yes. After that it is an ordinary Git commit.
Ingot is a desktop AI IDE for macOS, Windows and Linux, now in beta, with Rex (Zaprex) as the background agent that works while you're away. The editor is free. AI starts at $15 a month. This article is a full tour of the ideas in both products — what you can use in the beta today, what is documented as beta and still being built, and what is coming soon.
Ingot in dark mode: an agent edit under review, hunk by hunk, with the chat on the right.
How we label status
The whole product is a desktop beta. Inside that, we use three labels, taken from the public docs:
- In the beta today. Documented as usable, without a "coming soon" banner: the core agent chat, models, Git workflow, MCP, rules, the store, settings, the CLI, and Ingot in the browser.
- Beta, still being built. The docs carry a beta notice: names, settings and defaults may change before the feature fully ships. We still describe what the docs say it does, because much of it already runs in the app.
- Coming soon. Planned work that is not available yet, or that we are still building as a gap. We do not treat a ticket or a research note as a shipped feature.
Table of contents
- Hunk-by-hunk review
- Diff viewer, apply arrows and smart merge
- Agent chat and modes
- Models, keys and mid-run switching
- Tab completion and inline edit
- Image notes and pin-notes
- App Preview and the Visual editor
- Design-to-code from Figma
- Command Center
- Habits, rules, knowledge and the .ingot folder
- Game changers
- Arena mode
- Automations, missions and tickets
- The store, extensions and MCP
- Rex (Zaprex) and Rex Crew
- Git and source control
- A real IDE around the agent
- Codebase index, Digital Twin and context
- Privacy, sandbox and policy
- Ingot Web, mobile, headless and the CLI
- Teams, Together and what's coming soon
- What it costs
- A note on the beta
- We're looking for founding teams
Hunk-by-hunk review
Status: in the beta today.
In the agent chat, edits stream in as a code-change block, one block per file. The same hunks appear inline in the editor, with Accept and Reject on each one. You can also accept or reject the whole file. Those two views stay in sync: a decision in the editor updates the chat block, and a decision in the chat updates the editor.
There is a dedicated Review tab as well. The left side is Before. The right side is the agent version, which is the real file and is editable, so you can fix a line by hand without leaving the review. Unchanged regions are folded, with a little surrounding context. Each file shows as Pending, Accepted, Rejected, or Partly accepted. The toolbar keeps a small running total, along the lines of 3 files · +42 −7 · 2 pending.
The keyboard is meant to feel like a review, not a form: accept file, reject file, and previous / next hunk. If you already trust the run, Accept all and Reject all are there.
The rule that makes the rest possible: while hunks are pending, the agent's edits are not saved as your files. You can still read them, step through them, and reject them. Accepting a hunk is what writes it. If the agent "fixes" a test by weakening it, rejecting that hunk is not an undo of a write that already happened. The bad edit never became the file. The good hunks can still land.
If you edit a file that still has pending hunks, either in the ordinary editor or in the Review tab, Ingot recomputes the hunks a moment later, so Accept and Reject still apply to what you are looking at.
Light mode: Accept or Reject on the hunk in the editor, and on the whole file in the chat.
The same review step in dark mode.
Several chats can run at once, listed in a Threads sidebar (running, needs review, done, error). When a thread finishes you get a notification that a certain number of files are waiting. The same Review tab can show every file the latest run changed, plus older changes that are still waiting for a decision. If you want a thread's edits off your main checkout, you can start it in its own git worktree. The agent works on a new branch beside the repository, and you merge when you are happy.
Hunk review is about what lands in the file. A separate system is about what the agent is allowed to attempt. Each project has a sandbox preset (read-only, workspace write, or full access) and an approvals preset (ask, never ask, or auto-review). Workspace write is the default; network access is off unless you turn it on. Actions that leave the sandbox — writes outside the project, the network, a policy change — show up as an approval card.
Local history (beta, still being built). Ingot keeps a private version of a file every time you save it and every time an agent changes it, so you can compare with an earlier version and put it back even if you never committed it. Versions live in .ingot/history/ on this machine (the newest 100 per file) and are git-ignored. Labels include Saved, Before agent edit, Agent edit, and Before restore.
Agent review before commit (beta, still being built). You can also ask the agent to review staged changes (or all changes) before you commit, including a Find issues pass, with findings and fixes under a cost cap. The same idea is available from the ingot review CLI command.
Diff viewer, apply arrows and smart merge
Status: beta, still being built.
Reviewing an agent run should feel like reviewing any other change. The diff viewer opens from Local Changes, the Commit window, or the agent review block in the chat. Every change gets gutter arrows: « applies the change, » reverts it. You can accept or reject a whole file. In Unified mode both arrows sit in the one gutter. For an agent run, « accepts the agent's edit for those lines, and » puts the lines back the way they were before the run.
Apply or revert each change with gutter arrows, or take the whole file at once.
When a file has a merge conflict — after a merge, rebase, or cherry-pick — it opens in a three-way view: yours on the left, the result in the middle (you can type in it), theirs on the right. Smart merge runs when the file opens. Every change that only one side made, or both sides made the same way, goes into the result. What is left are the real conflicts, where both sides changed the same lines differently. The header says something like 1 conflict · 2 auto-merged.
Smart merge also looks inside a line both sides edited. It splits the line into tokens and merges them: if you renamed total to count and they changed add(a, b) to add(a, c), the result is count = add(a, c). Those lines are marked auto-resolved same-line, with a wand in the gutter. You can still take a side with the arrows, ignore a change, accept a whole side, or press Apply when every conflict is resolved. Apply writes the result, stages it, and marks the file resolved. The same merge is also available from ingot merge on the command line.
Smart merge: non-conflicting changes, including same-line edits, land in the result. Only true clashes stay as conflicts.
Agent chat and modes
Status: in the beta today (the chat itself). Several surrounding surfaces are beta, still being built.
Talk to agents about real code. Copy lines from the editor and paste: you get a file and line-range chip in the sentence, not a wall of text. Images and @ mentions work the same way. Edits arrive as the reviewable change blocks above. A small context ring shows how full the model window is, split into system, rules, files, memories and conversation. Near the limit, you can summarize and continue.
Pick a mode from the composer's mode pill, or cycle modes from the keyboard. Each mode decides what the model may edit and which tools it may call:
| Mode | What it does |
|---|---|
| Agent | Reads, edits and runs tools to complete the task. Edits arrive for review. |
| Multi-agent | Splits the task across up to 4 sub-agents that work in parallel, then merges their results. |
| Ask | Answers questions about your code. Read-only: no edits. |
| Plan | Researches and writes a step-by-step plan before any code changes. |
| Debug | Reproduces the problem and reads recent terminal lines and diagnostics to find the cause. |
| Deep research | Searches the web, Reddit, Hacker News, GitHub and Stack Exchange, reads many pages and answers with cited sources. |
Agents can also remember short facts and preferences between chats, per project or globally, as plain Markdown files you can edit.
Other chat pieces, all beta, still being built, and already described in the docs:
-
Inline chips, tags and files. Paste lines, drop files, or type
@and/to attach files, pins, rules and projects. You can also drag images and logs into the composer. - Queue, edit and rerun. Steer a running agent without stopping it, edit a sent prompt, or rerun a turn.
- Chat layout and the changes tray. A compact review bar, session panes when several agents run at once, and a timeline thread.
-
/goaland custom modes. Hold a goal until checks pass, and define your own modes. - Long tasks and big files. A working context you can configure, plus tools for large files.
- Reply recovery. If a reply fails part-way, the thread can recover rather than drop the work.
- Focused agent layout. Hide the extra chrome and keep the editor and the agent.
On first run, a short setup covers keymap and theme, a privacy-and-agent preset (Private, Balanced or Fast), and how you want models: sign in, use your own keys, or continue without AI. Help › Set Up Ingot… opens it again. Optional features can also show up as a small suggestion above the chat, a switch in Settings › Features, or a status-bar button.
Models, keys and mid-run switching
Status: in the beta today.
On a paid plan, three kinds of model sit in one picker: hosted Ingot models (Ingot, Ingot Fast, Smart, Reasoning, plus specific models from the major families), your own keys (Claude, GPT, Gemini, DeepSeek, or any chat-completions compatible endpoint), and local models through Ollama (default http://127.0.0.1:11434). You can switch models mid-run, while an agent is already working, not only between turns. Start on a fast model for the mechanical work; when the task gets harder, switch to a stronger model in the same chat, with the same context.
Your own keys are stored in a local key file and are billed by your provider. Local model requests stay on your machine. Ingot Fast, Smart and Reasoning are aliases with a fallback chain behind them, so a provider outage does not stop your agent.
Usage and on-demand are explained on the pricing page and in Usage & on-demand. Token units reset on the 1st of every month (UTC). Team units are pooled across seats.
Tab completion and inline edit
Status: beta, still being built.
Tab completion. As you type, Tab predicts the rest of your edit and shows it as grey ghost text: the end of the line, or several lines when you start a block or a function (up to 16 lines). Press Tab to take it, ⌘→ (Ctrl+→) for the next word, or Esc to dismiss. When your change means another line must change too, Tab jumps there and applies that edit as well. In the agent chat, Tab can also finish the message you are typing. Tab is on by default and uses a fast, cheap model. It can also run for free on a coder model in Ollama on your computer, offline (Free local Tab).
We are still working on Tab quality — latency, next-edit jumps, and usage stats — as planned follow-through, not as a claim that the work is finished.
Inline edit. Select some code, press ⌘K (Ctrl+K) when there is a selection, and say what to change. The model rewrites just those lines, and you review the result as an inline diff, with Accept and Reject on each change. (With no selection, ⌘K still opens the Commit window, as in the Git workflow.) Every inline edit is saved in Local history before and after.
In-file agent mode. Prefer to stay in the code? A gutter icon on a line opens a card where you can ask the agent right where you are. Unlike an inline edit, this is a full agent run: it can read and search the project and change this file or any other. When it finishes, the edits wait for review in the editor.
Image notes and pin-notes
Status: beta, still being built.
Paste a screenshot into the chat and the agent can point at what it means. You can also draw your own notes on an image before you send it: a box around an area, an arrow from one point to another, a pin on one spot, or a short text label. Type what each note is about, then attach the annotated image. The agent gets both the picture and a numbered list of your notes with their places.
In the reply, the agent can point back: numbered boxes, arrows, pins and labels on a copy of the image, each number linked to the sentence that explains it. Click a number in the text and the note on the image highlights. You can save the annotated copy to your project. Image data stays in memory for the session only; the notes are stored as fractions of the image size, so they stay in place at any zoom.
Paste a screenshot, pin notes on it, and the agent points at what it means.
App Preview and the Visual editor
Status: beta, still being built. Already on the pricing page: click-to-code comes with Bronze and up; the full Visual editor (edits and “tell the agent”) comes with Silver, Gold and Platinum.
The fastest way to change a UI is often to click it. App Preview shows the app your dev server is running, next to your code. Ingot finds the local dev servers and other local pages that serve HTML. You can switch ports, try the layout as a phone, tablet or desktop (or a custom size), rotate, zoom, and pick an element on the page to send it to the agent. The agent gets the element's selector, its source file and its styles. A related Mobile preview surface is documented the same way.
The Visual editor is its own mode on top of that preview: your app large in the middle, the code beside it, the agent chat on the right, and your components at the bottom. Hover outlines the element under the pointer. Click it, and its file opens beside the preview with the caret on that line. Links and buttons are selected, not followed or pressed. Minimize the mode and the IDE is back exactly as you left it. Nothing is added to the project: no plugin, no config file.
The selected element goes into the agent chat as a chip, for example button.buy · ProductCard.jsx:8. Type what you want next to it and send: the agent gets the element path, props, source file and line, selector, styles and HTML, with your words. On Silver and up you can also edit props and styles in a panel beside the page; each change is one undoable edit, saved, and the preview updates as the dev server reloads.
Visual editor, light mode: click an element in the running app and land in the source. The selected element is a chip in the chat.
The same layout in dark mode.
Design-to-code from Figma
Status: in the beta today for the Figma MCP connection; the visual loop and image notes around it are beta, still being built.
Design-to-code, for us, is not a separate product. It is the agent, the preview, and the notes you put on a design, used together.
Figma is one of the MCP servers you can connect in Ingot (and in the Zaprex desktop app). The agent can read frames and layers, get components and styles, and export images. You can connect through Figma desktop's local MCP server (Dev Mode) or with a token. You can also paste a screenshot of a design into the chat, pin notes on the bits that are wrong, open the running app in App Preview, click the matching element, and ask the agent to match the design.
Command Center
Status: beta, still being built. Offered as a free marketplace extension; the board is also built in.
Once you run more than one agent, you need a board, not another chat tab. The Agent Command Center (also listed as Agent Board) puts local and cloud agents on one Kanban board, from Queued to Done — including Needs you, To review, and Stopped or failed — with status, logs and pull requests.
The marketplace listing is a free extension: Install turns the built-in board on, Uninstall turns it off. You can also enable it from Settings › Features, the status bar, Find Action, or a short suggestion in the chat when two or more agents are running. There is only one board, whichever way you turn it on. The same view is available from ingot agents in the terminal.
Agent Command Center, dark mode: every local and cloud agent on one board.
The same board in light mode.
Related surfaces, also beta, still being built:
- Agent Manager and subagents. Multi-agent runs that split work, then merge results.
- Session Panes. Side-by-side chats when several agents are running.
- Worktree tabs. A tab per agent worktree, so two in-flight tasks stay off each other's checkout.
- Cloud agent hand-off. Send a chat or its plan to an Ingot cloud agent on your GitHub repository. It runs the tests and opens a draft pull request. The Cloud Agents panel lists runs (Queued, Running, Needs approval, Done, Failed, Cancelled, Timed out), with the log, cancel, checkout and follow-up.
Habits, rules, knowledge and the .ingot folder
Habits: beta, still being built. Rules, AGENTS.md and settings: in the beta today.
.ingot is where a project keeps rules, core rules, habits, knowledge, agents, skills, commands and workflows, as plain files. The agent reads them on its own, and it can write new habits and knowledge when it learns something. Each save can show up in the chat with Undo and Open. Slash commands let you see and change the files from the chat. On first open of a project that has no .ingot, Ingot can create the base tree for you.
Rules. Project rules live in .ingot/rules. Ingot also reads AGENTS.md and can import existing AI rule folders into .ingot. Type / in the agent for rules, skills and commands. There are also core rules by task type, effective rules, learned rules, rule hits and provenance, a Rules Doctor, rule tests, and prune stale rules. You can export rules to the formats used by other tools, including for CI. We do not treat those export targets as a reason to name other editors here.
Habits. Habits are how the agent keeps what it learned about this project. They live in .ingot/habits/, with one Markdown file per type of fix: bug.md, defect.md, design.md, performance.md, tests.md, security.md, refactor.md, general.md, and any type you add. Each file holds lasting knowledge: decisions, patterns, and "always do X when Y." The agent reads the files that fit the task and appends what it learns. Commit the folder and your team's agents learn together. Habits is optional and off until you turn it on — from a suggestion in the chat, Settings › Features, or the Habits button in the status bar. Rules say how to write code; habits are what the agent learned about working in this project. Habit classes and Habits packs in the store extend the same idea.
Knowledge and shared context (beta, still being built). Lasting project knowledge, decisions and dependencies can live under .ingot as well, including a shared project context that agents and teammates can add to, mark outdated, or sync into AGENTS.md.
Hooks (in the beta today). Project hooks can run at agent and Git events, as a counterpart to rules and MCP.
Game changers
Status: beta, still being built. The docs group six features that fix what goes wrong in long agent sessions. They are off until you turn them on in Settings › Tools › Game changers (the model router stays off even then, until you enable it). Everything they store is a plain file in .ingot. Repeated patterns can become Habits. When one of them saves something, a small silver note appears under the agent's reply.
Decision Ledger
Keeps a list of what you and the agent agreed on, in .ingot/decisions.md, and asks before the agent goes against a locked decision. A decision you confirm again and again can be promoted to a habit.
Frozen Zones
Marks files and functions the agent may not change without your OK, in .ingot/frozen.json. You can keep it frozen, allow this edit, or unfreeze. Code you keep reverting agent edits to can be offered as a frozen zone.
Frozen Zones: the agent stops on protected code and asks before it edits.
Doom-Loop Breaker
Spots fix-and-break cycles, the same error after several tries, a repeated step that changes nothing, or contradictory claims. It is on by default. The first time, the agent must rethink with the evidence. If the loop comes back, the run pauses and asks whether to try a different approach, reset, keep going, or stop.
Fresh-Context Auto-Handoff
Long chats get worse over time. In the same chat, when a run nears 80% of the working context, the agent summarizes its state and continues under a divider, without an extra model call. Between turns, when a chat looks stale (repeated failures, a long thread, a packed context), Ingot offers — or, in auto mode, starts — a new chat seeded with a brief in .ingot/handoffs/, including the goal, the approved plan, locked decisions, the current diff and the next step.
Plan-Diff Review
You review the approved plan, not only every line of the result. Afterwards Ingot checks the implementation against that plan and flags drift and unexpected scope. Plans can live in .ingot/plans/.
Cost Forecast and Model Router
As you type, a chip next to the model can show an estimate for the request (for example ≈ $0.18 · 42k tokens). Above a threshold you set, Send asks first: send anyway, use a cheaper model, or cancel. With the router on, simple steps (reading files, short edits, commit messages) can go to a cheaper model, and the hard parts stay on the model you picked. Routed steps get a note you can rerun on your model. The router only uses models you already have access to. The forecast is an estimate; the real cost of a run depends on how many steps the agent takes.
Arena mode
Status: beta, still being built. Off until you turn it on.
Arena runs one task with two agents whose models stay hidden, so you compare the results blind, vote for the better one, and only then see which model was which. Each agent works in its own git worktree, so neither touches your project. After the vote you can apply the winner's changes as ordinary agent changes to review, or discard both worktrees. Every vote goes into your own model leaderboard. Open Arena from the status bar, Find Action, or /arena in the chat.
Arena: two hidden models, a blind vote, then apply the winner for review.
A judged "best of several attempts" flow, and a security-focused PR reviewer on top of Arena, are still coming soon.
Automations, missions and tickets
Status: beta, still being built.
Automations. An automation is a Markdown file in .ingot/automations/, reviewed like code. It can start an agent on a pull request, a comment that mentions @ingot, a CI failure, a Slack mention or slash command, a Linear issue or comment, a webhook, or a cron schedule. It can run in the open IDE (run: local) or on an Ingot cloud agent while the IDE is closed (run: cloud). With a goal, the agent keeps working until a check passes or it hits a turn cap. Bot events, and events Ingot itself sent, never start an automation, so it cannot loop on itself.
Automations: a CI failure starts an agent, and a goal check holds the run until the tests pass.
Fix a ticket (beta, still being built). Point the agent at a tracker issue and follow the work through to a pull request.
Follow PR to green, Ship, and Missions (beta, still being built). Follow a pull request until checks pass; a Ship flow around the Push dialog; and longer Missions that keep a larger goal in view.
Ask and do on your computer / Use your computer like an assistant (beta, still being built). Let the agent work with local files and tasks on the machine, under the same approval rules as the rest of the product.
The store, extensions and MCP
Store and MCP: in the beta today. Several marketplace and extension surfaces are beta, still being built.
The Ingot and Zaprex store lists themes, Habits packs, rules packs, one-click MCP servers, Ingot extensions such as the Agent Command Center, and Rex templates and extensions. The editor also has a store for extensions and color themes from Open VSX, and an SDK plus the ingot CLI to package and publish your own (ingot.json, validate, package, publish). Store guidelines are public; listings should describe what an extension does today, not a roadmap, and the store does not show download counts or ratings.
MCP tools — GitHub, GitLab, Jira and Confluence, Linear, Slack, Notion, Figma, Postgres, and many others — can be added in one click. Servers that sign in with OAuth open the browser once. Tokens go in Ingot's local key file (~/.ingot/keystore.json); the committed config only keeps a placeholder. You can use a project file or a global one. Existing mcp.json files are read as they are, including servers you imported from another editor, which stay off until you turn them on.
One-click MCP: pick a server, turn it on, and the agent can use it. Figma is in the catalog for design files.
Deeper MCP work is still coming soon: a newer protocol revision, streamable HTTP, tighter OAuth and tool-approval, and health status for remote servers. Some of that is already sketched in the Remote MCP docs; it is not the finished end-to-end story.
Other extension topics in the docs, beta, still being built unless noted: marketplace search, marketplace extensions (Agent Board and Rex Crew), extension guard, blocked shell extensions, icon packs, theme tokens, and feature discovery (how optional features are suggested in the chat, Settings, and the status bar).
Rex (Zaprex) and Rex Crew
Rex in the Zaprex app: in beta today. Several Rex desktop and crew surfaces are beta, still being built. Some Rex ideas are coming soon and are called out at the end of this section.
Rex (Zaprex) is Ingot's background coding agent. Ingot's own agent works with you in the editor, live. Rex works on its own, in a fresh isolated cloud sandbox, while you do something else, and hands you a draft pull request. They share one account and one plan, but they are different apps. In the Ingot IDE, the small T-rex next to the agent opens the Zaprex app at zaprex.dev/app. There are also desktop and mobile Zaprex apps, with the same account and chats.
Rex is good at the work that keeps slipping: fixing failing tests, small changes you keep postponing, routines on a schedule (for example a nightly test-and-fix), and follow-ups on review comments. You give it a task in the Zaprex app, or a routine starts one. It reads, edits and runs your tests in the sandbox, pauses for your approval before anything risky, and finishes by pushing a new branch and opening a draft pull request. It never pushes to main. You get an in-app and email notification when a run needs you or a PR is ready.
In the app you can chat or start a run, attach files and images, search the web with citations, send a link and have Rex read the page, and write in any language. A chat can carry one project or several. A light Ingot panel can sit beside a folder or workspace chat so you can browse files and accept or revert what Rex changed. Memory is per user and per project, and you can view, edit or forget it. The run log shows every step: status, commands, test output, diffs and the model used. GitHub is the Git host today; others may come later.
Handing a heavy task to Rex is available on Silver and up. Bronze includes 40 Zaprex minutes a month and draft pull requests. Plans and limits follow the Ingot pricing page, not older plan names you may still see on some Zaprex help pages.
Rex Crew (beta, still being built) is a free marketplace extension for Rex and Ingot. Rex manages outside agent apps on your computer — Claude Code, Codex, Grok, and the other agent CLIs — with a live crew matrix, labeled hand-off arrows, and each agent's real logs and commands.
Other Rex docs, also beta, still being built: sending tasks from Rex to Ingot and other agents; Ask and do on your computer; app tools, logos and per-app Allow cards; Rex automations; connect apps and Git accounts; Rex home and Settings; window layout; tool calls; and Rex offering to take a step.
Coming soon for Rex (the official coming-soon page; none of this works in Rex today):
- Rex's own
.zxconfig language in a.zaprexfolder (project and global), for settings, rules, learnings and custom commands. It is declarative and never runs code. - Automatic discovery and merge of those folders.
-
/commands and@mentions in the Rex chat. - Automatic learning, with an Undo note in the chat. Secrets are never saved.
- A
rexCLI (rex do,rex chat,rex status).
X and LinkedIn are listed in Settings › Connections and show "Not available yet" until they are turned on. Ask Rex, the assistant on zaprex.dev, already answers questions about Zaprex and Ingot from the public docs, with links; it cannot see your account or start a run.
Git and source control
Git workflow: in the beta today. Several related views are beta, still being built.
Git is built in: a Commit window with changelists, unversioned files, per-chunk include and exclude, amend, sign-off and message history (⌘K); a Push dialog so you see which commits go where (⇧⌘K); annotate / blame in the gutter; line history; and the three-pane merge above. You can stage just the hunks you want and commit in the same place you write the code.
The Commit window: stage the hunks you want, write the message, and commit without leaving the IDE.
Also documented:
- Multi git (beta, still being built): every repository in one window, on Bronze and up.
- Git Hosts, branches popup, Source Control view, Changes side panel, nested repositories, folders without Git, and file change colors (beta, still being built).
- Agent commits (beta, still being built): the agent can propose a commit after you have accepted the hunks, rather than going around review.
A real IDE around the agent
We needed a real IDE around that review step, not a longer feature list for its own sake.
In the beta today: a compact, keyboard-first layout; the Ingot keymap (Search Everywhere, Find Action) or Classic; Settings as a UI and as JSON (~/.ingot/settings.json and project settings); sign-in and accounts; installers for macOS, Windows and Linux; and a What's New / email changelog.
Beta, still being built, and already in the docs:
-
Modal editing. Vim-style Normal, Insert and Visual modes, with familiar motions and a set of ex commands (
:w,:q,:wq). Ingot shortcuts and the agent chat keep working. Not supported yet: a.vimrc, custom mappings, relative line numbers, and some ex commands. - Themes and color themes, including a theme picker and custom theme tokens. Built-in themes include Light, Dark, System and Ember.
- Import an existing setup from another editor, without naming those editors in the UI.
- Language support, the terminal, Test Explorer, a built-in browser, tool windows, the status bar, project tabs, bottom panel tabs, workspaces with several folders, and a welcome screen.
- Code tools the agent can call (renames, search, and other IDE actions), plus AI code review.
- Health, updates, release channels, workspace trust, project environment, ignore files, run icons, attribution (Made by Ingot IDE), and feedback.
-
External agents (ACP). Run OpenCode, Goose, OpenHands, or another Agent Client Protocol agent from a panel and from
ingot acp. This is still being finished; bringing those agents all the way into the everyday IDE workflow is also on the planned list. - Remote control, so you can steer a running session from another device, still being built.
Codebase index, Digital Twin and context
Codebase index and search: beta, still being built. (The mechanics are documented in detail.)
Ingot keeps a local index of your project so agents can find code from a plain-words description, not only from an exact string. Files are split into overlapping 40-line chunks. By default embeddings are computed on your machine from the words in each chunk, with no model and no network. Nothing is uploaded. For matches by meaning you can switch to an embedding model in Ollama. The index follows your ignore files, skips secrets, binaries and build output, and caps at 50,000 files per project. It lives in .ingot/index/ and ignores itself in git. Agents call codebase_search; you can also use @codebase. The status bar shows Indexing, Index ready, or Index error.
Project Digital Twin (beta, still being built). A living model of the project, built from the code: packages, components, routes, APIs, tests and the imports that link them. The Project Twin panel answers "what touches this file?" for the file you have open — imported by, tests that reach it, routes and APIs above it, and what it imports — and updates itself when you save. It is stored in .ingot/twin/ and is not committed; it is rebuilt from the code. Digital Twin is a Silver-and-up plan feature.
Context Engine, project map / repo map, and context memories are documented companion surfaces, also beta, still being built. Memories remain editable Markdown, per project or global.
Privacy, sandbox and policy
Status: mixed. Privacy mode, the sandbox and a local audit trail exist in the beta and are documented; several enterprise pieces are still coming soon.
Your files stay on your machine. We do not upload your repo or the local codebase index. Code leaves the computer only when you start a request (chat, inline edit, or a hosted-model prediction), and then only to the model provider for that request. We do not store the text of prompts or replies; we keep a usage record (model, tokens, cost, time). We do not use your content to train models, and we do not use analytics or advertising trackers.
Privacy mode is on by default for Ingot-hosted models: only zero-retention routes, and if no private route exists the request stops instead of falling back. Requests with your own key go straight from your computer to that provider. Local models never leave the machine. Synced settings (on by default when you sign in) include editor settings, keybindings, rule files, and chat titles and order — not chat message bodies. Crash reports, if enabled, are scrubbed and do not include your code, user id, email or IP.
The sandbox and approval cards are described under review above. The Agent policy and audit log are documented; today's audit log is local per machine (~/.ingot/audit). A current limitation we will be honest about: command sandboxing is not yet at the same level on every platform (Windows and Linux still need to catch up with macOS). That work is planned.
Coming soon on the enterprise side: SSO (SAML/OIDC) and SCIM; an org admin console for seats, roles, a model allow-list and budgets; org-managed policy pushed from the server (MCP allow-list, rules, sandbox, privacy) that is not user-overridable; a central exportable audit log (SIEM/API); a self-hosted or VPC agent and model gateway so code need not leave the company's network; richer admin usage analytics; and SOC 2 / compliance pages and a trust center. Platinum already lists roles, permissions, shared rules, a team usage dashboard and admin caps; the items above are the larger policy and compliance story still to land.
Ingot Web, mobile, headless and the CLI
Ingot in your browser: in the beta today. Web projects, mobile preview, and headless ingot serve: beta, still being built. The ingot CLI reference: in the beta today.
One plan covers the desktop app, Ingot Web and the mobile app: one account, one price, the same usage and limits. Ingot Free includes 1 Web project with AI off; Bronze 3, Silver 5, Gold 7, with AI on. Each extra Web project is $2.50 a month, and Ingot asks before adding one.
Headless Ingot (ingot serve) runs the IDE on your own server, VM or home box, with no desktop window. You open the project as Ingot Web through the Ingot relay. Nothing for that session runs in the Ingot cloud for you; the IDE stays on your machine and keeps one outgoing, encrypted connection. You don't open an inbound port.
The CLI (@ingotide/cli) can scaffold, validate, package and publish extensions; test and prune rules; review changes; predict Tab; compose chat context; work with learnings, image notes, smart merge, cloud hand-off, App Preview, usage, the Agent Command Center, automations, ACP, and Arena. A fuller headless agent CLI and SDK for CI scripts (machine-readable output end to end) is still coming soon as a gap we are closing, on top of what the CLI already does.
Teams, Together and what's coming soon
Teams, roles, team rules, team policies and team triggers: beta, still being built.
Platinum is the team plan: per-seat billing, roles and permissions, shared rules and skills, a team usage dashboard, and admin caps. The docs also describe team policies, team rules and team triggers. Those surfaces are still being built.
Ingot Together (beta, still being built). Work live with teammates, and let agents in a session talk to each other, ask, hand off tasks and claim files. This is the start of real-time collaboration and shared agent sessions; a fuller "work live in one session" story is still coming.
Below is the rest of the planned work, including the November gap list, written as product ideas rather than ticket IDs. Where a related capability already exists, we say so.
- MCP end to end. Newer protocol support, streamable HTTP, OAuth for remote servers, tool approval and health status — building on the one-click MCP already in the beta.
- Privacy and data policy. Privacy mode already exists; a fuller stated data-retention policy is still being finished.
- SSO, SCIM and org admin, and org-managed policy that users cannot override.
- A central, exportable audit log, beyond the per-machine log today.
- Sandbox parity on Windows and Linux.
- A PR review bot on GitHub and GitLab (comments on every PR, Fix All, learned rules, security review), on top of in-IDE review and Follow PR to green.
- Cloud and background agents that keep running and resume from the web or phone. Rex already runs in a cloud sandbox and has web and mobile apps; this gap is about agents that persist and resume more like a long-lived VM.
- An auto-approve classifier: approve routine actions, block risky ones, ask about the rest — on top of today's approval presets.
- Triggers from Slack, Jira, Linear and GitHub issues — already sketched as Automations, still being built out.
- Remote development: SSH, Dev Containers and WSL.
- A spec-driven workflow: requirements, design and tasks before code.
- Admin usage and adoption analytics (per user, model, cost, accepted lines).
- Self-hosted / VPC agents and a model gateway.
- Memory learned from PR feedback and corrections, shared across the team ("team brain" / team conventions from review history).
- A browser agent that runs the app, clicks through flows and records video as proof.
- Terminal agent quality: long-running processes, background shells, live output — on top of today's terminal and Debug mode.
- Checkpoints per agent step, with one-click restore of files and chat, on top of Local history and worktrees.
- SOC 2, compliance pages and a trust center.
Further game-changer ideas, coming soon (not available today):
- Proof-carrying changes: every agent change ships with evidence, and merge can be gated on it; a "verified changes" proof card a reviewer can trust quickly.
- Behavior lock: characterization tests before the agent refactors.
- Best-of-N judged by tests: parallel attempts, keep the one that passes with the smallest diff.
- Blast radius: impact analysis, a risk score and suggested reviewers for every change.
- Air-gapped mode: a fully local AI IDE with zero outbound traffic (local models already stay on the machine; this is the stricter, no-account product mode).
- A migration specialist: large codebase migrations as a stream of small, proven PRs.
- Watch the deploy: after merge, Rex watches the deployment and offers a fix or rollback.
- A new-teammate tour: "Explain this project" as a guided walkthrough in the IDE.
What it costs
The editor is free forever ($0): Git, terminal, debugger, the diff viewer, free plugins and themes, settings sync on 1 device, and Ingot Web with 1 project and no AI. AI features, including your own keys and local models, are on a paid plan. They are not free during beta.
The editor is free forever. AI starts at $15 a month. Early signups get 2 weeks free on low-cost models.
- Ingot Bronze is $15 a month for 15M token units. It includes Ingot (our own model) as the default, premium models, your own keys and local models, multi git, visual-editor click-to-code, and 40 Zaprex minutes.
- Silver is $55 a month: 60M units, the full Visual editor (edits and “tell the agent”), 2 agents at once, Project Digital Twin, and 300 Zaprex minutes, including handing a heavy task to Rex.
- Gold is $179 a month: 220M units, 4 agents, and 1,200 Zaprex minutes.
- Platinum is $40 a seat a month for teams.
Early signups get 2 weeks free on Ingot's low-cost models, with a cap on requests. On-demand is opt-in at model cost plus 35%, with a hard cap you set. Ingot and Ingot Fast use 1 unit per token; premium models use 15. One plan covers the desktop app, Ingot Web and the mobile app. Yearly plans include about two months free.
Full detail is on the pricing page: ingotide.com/pricing.
A note on the beta
This is a desktop beta. Installers are at ingotide.com/download for macOS, Windows and Linux. As of 21 November 2026, Apple Silicon Mac is 0.1.0-beta.10; Windows, Linux (x64 AppImage) and Intel Mac are 0.1.0-beta.4. Builds are unsigned, so you may see a Gatekeeper or SmartScreen warning the first time. We should get those platforms onto the same beta; until then the download page is the source of truth.
If a docs page still mentions building from source or an open-source license, that wording is out of date and is being corrected. Ingot is not open source, and there is no public repo. The desktop editor is free to download.
We're looking for founding teams
If you already review agent patches in a real repository, the useful test is not a fresh demo app. Ask for a change you would actually ship, accept the hunks that belong to it, and reject the ones that do not. Then tell us whether the right hunks were obvious, and whether a rejected hunk left the file in a sensible state.
We are inviting teams to run a pilot. Founding teams get Ingot Platinum at $25 a seat for the first year, instead of $40. In return we ask for a regular call and your bug reports. Ask at sales@ingotide.com, or start from ingotide.com/pricing.
We launch on Product Hunt on 1 December 2026.
A few short demos, if you want to see it first:
- PHP bookmarks app, prompt to PHPUnit: https://youtu.be/c44r_sgtFAw
- Click the running app, jump to the code: https://youtu.be/Br2cdQucJ2A
- Java and Spring Boot, prompt to passing Maven tests: https://youtu.be/26_gDjZKn8o
- React Native, almost without typing: https://youtu.be/xxET77YZbiU
More on the Ingot YouTube channel. Docs for every feature above live at ingotide.com/docs and zaprex.dev/docs.
Download the beta: https://www.ingotide.com
Questions, pilots, and support:
來源:DEV Community · dev.to















