Google Antigravity 2.10.0 Makes the Agent Sidebar a Workbench
Google Antigravity 2.10.0 moves terminal execution, Git review, MCP visibility, and multimodal feedback into one coding-agent control surface.
Google published Antigravity 2.10.0 on August 24, 2026. The release is not a model announcement, and that is what makes it interesting. The useful part is the harness work: an embedded terminal, Git-native review controls, richer MCP tool execution previews, image-region comments, audio attachments, and performance fixes in the same agent surface.
That combination points at where coding agents are actually going. The agent is no longer just a chat panel that happens to edit files. It is becoming an engineering workbench with terminal state, version-control state, tool-call state, and review feedback visible in one place.
What Happened
Antigravity 2.10.0 shipped with a set of workflow features aimed at reducing context switching inside long-running coding-agent sessions. According to Google's changelog, the release adds an embedded terminal directly in the sidebar, Git version control in the Review pane, structured display for MCP and custom-tool execution steps, audio file attachments up to 20 MB, region-based image comments, typo-tolerant file search in @ mentions, frontmatter formatting in Markdown previews, and several reliability fixes around comments, attachments, sandbox-mode settings, and business-login error handling.
The new terminal matters because it gives the user a first-class place to run build commands, tests, migrations, local scripts, or diagnostics without leaving the agent's workspace. Antigravity's docs now describe terminal support as available directly from the sidebar, with access through the terminal button or Ctrl/Cmd + backtick. That is not a novel IDE feature in isolation. It is novel because it sits inside the same control surface that is also managing agent conversations, artifacts, comments, and review state.
The Git work is similar. Google's feature documentation says Antigravity 2.0 now provides a Git-native VCS review panel in the sidebar. It can show staged and unstaged working tree changes, branch diffs, and diffs originating from agent tool edits. It also supports staging, unstaging, discarding file changes, committing locally, and pushing to a remote. The 2.10.0 changelog adds that Git responsiveness and background CPU usage were improved for large repositories and projects with submodules.
The MCP improvement is more subtle but probably more important for teams connecting agents to real systems. In 2.10.0, MCP and custom tool execution steps now show structured headers, expandable argument blocks, and formatted result previews. Antigravity's MCP docs describe MCP as the bridge that lets agents fetch structured context or execute safe actions through local tools, databases, file parsers, and remote APIs. Improving how those calls render is not cosmetic. It changes whether a developer can inspect what the agent is doing before the transcript becomes an unreadable stream of opaque tool names.
The release also continues Google's broader Antigravity 2.0 direction. The product page describes Antigravity 2.0 as a command center for multiple local agents, projects, multiple workspaces, and scheduled messages. The getting-started docs say projects define the folders and repositories agents can access, support local mode and isolated Git worktree mode, and can carry project-specific settings and security policies.
Why It Matters
Experienced engineers do not need another agent chat UI. They need fewer unobservable handoffs.
The fragile part of coding-agent work is usually not the model's ability to draft code. It is the operational loop around the model: which files did it touch, which commands did it run, which tool calls changed its plan, which diff is ready for review, which comment did the human leave, and whether the result still builds after the last edit. When those signals live across a terminal, an IDE, a browser tab, a Git client, and a chat transcript, the human supervisor becomes the integration layer.
That is backwards. If an agent is going to work across a repository for twenty minutes or two hours, the harness should be responsible for preserving enough state that a reviewer can reason about the session without replaying the whole conversation.
Antigravity 2.10.0 is useful because it tightens that loop. The terminal gives the user and the agent a shared execution reference. The VCS panel turns agent edits into normal Git objects rather than mysterious file mutations. Structured MCP previews make external tool use inspectable. Image comments and audio attachments widen the review channel without reducing everything to prose. URL artifacts opening in an in-app preview pane pull local dev servers and Google Workspace references into the same workflow.
The obvious comparison is an IDE with an AI sidebar. That undersells the shift. In a normal IDE, the terminal and Git panels are primarily human tools. In an agent workbench, they are also supervision boundaries. They let you answer practical questions: Did the agent run the same command I would run? Did the diff include a generated file I do not want? Did a connected MCP server return a surprising payload? Did the review comment attach to the right image region? Did the local preview match the artifact the agent claimed it produced?
There is also a security angle. Google's feature docs say Antigravity is secure by default: agents request permission before running terminal commands, and by default they can read and write only within the project folders. Projects can have scoped settings and scoped permission grants. Those controls become easier to use when the tool surface is visible. Hidden approvals create rubber-stamping. Visible commands, visible diffs, and visible tool arguments create a chance for real review.
How It Works
The architecture is a familiar coding-agent pattern: a project boundary, an agent session, tools, artifacts, permissions, and review surfaces. What changed in 2.10.0 is how much of that loop is now surfaced in one place.
Projects are the outer boundary. Antigravity projects can include one or more folders or Git repositories, and the docs say multi-folder access lets agents operate across codebases in one conversation. Projects also carry scoped settings, so a trusted internal repository can use a different security posture from an unfamiliar checkout. When starting an agent, the user can run in local mode or in a new Git worktree mode, giving the agent an isolated background folder.
Inside that boundary, the terminal becomes a direct execution surface. A developer can run commands manually, but the larger point is that command execution no longer has to be mentally reconciled with a detached transcript. If the agent asks to run a test suite, the terminal is already part of the workbench. If the test fails, the failure can become context for the next turn without an awkward copy-paste step.
The VCS panel turns the file system result into a reviewable change set. It can separate staged and unstaged changes, branch diffs, and agent-originated edits. That last category matters because agent systems often mutate many files in one turn. Being able to inspect the subset that came from agent tool edits gives reviewers a cleaner audit trail than "here is the whole working tree."
MCP support connects the agent to systems outside the immediate repository. Antigravity supports local stdio servers and remote server configurations, with a standard mcpServers configuration object. The docs list transport options such as a local command or a remote serverUrl, optional environment variables, working directory, HTTP headers, OAuth, Google Application Default Credentials, and disabled tools. That means a team can expose a database schema, deployment logs, issue tracker, internal API catalog, or cloud service through the same tool protocol.
The danger with MCP is tool sprawl. A useful agent may have dozens or hundreds of possible tool calls. If the UI shows only "called tool" and a blob of JSON, the human stops reading. Antigravity 2.10.0's structured headers, expandable arguments, and formatted result previews are a direct answer to that problem. They make tool execution inspectable enough to remain part of the review loop.
The multimodal additions are less central, but still practical. Audio attachments let developers bring meeting snippets, bug reports, or spoken notes into the agent session. Region comments on images make visual feedback more precise for frontend, design-system, dashboard, and document workflows. These are not replacements for tests, but they reduce the amount of lossy translation between "this exact part is wrong" and a prompt the model can act on.
Example
Imagine a frontend engineer asking an agent to repair a flaky checkout flow in a monorepo. The relevant code spans a React app, a shared validation package, and a Playwright test suite. The bug report includes a screenshot where a totals panel overlaps a shipping-method selector.
In a weaker setup, the engineer would paste the bug text into a chat panel, wait for a diff, switch to a terminal to run tests, switch to Git to review changes, switch to a browser to inspect the local app, then paste failures back into the agent. Every switch loses context.
In the Antigravity 2.10.0 shape, the workflow can stay tighter:
Project:
folders:
- apps/storefront
- packages/checkout-validation
mode: new Git worktree
Agent task:
Reproduce the checkout layout bug, patch the smallest affected components,
update the Playwright coverage, and leave the final diff ready for review.The engineer can attach the screenshot and comment on the exact overlapping region. The agent can inspect the app and package folders within the project boundary. If it needs schema or issue-tracker context, an MCP server can provide it. When it proposes commands, the terminal approval appears in the same workflow. When it edits files, the VCS panel shows staged and unstaged changes, with agent-originated diffs available for inspection. If the local dev server or a Google Doc spec is part of the evidence, URL artifact cards can open supported links in the in-app preview pane.
The final result is not that the agent magically got smarter. The final result is that the human has a better operating console. That is what makes longer agent sessions tolerable: not perfect autonomy, but a shorter path from observation to correction.
My Take
This is the kind of release that matters more than it looks on a changelog.
The dominant failure mode for coding agents in experienced teams is not "the model cannot write any code." It is that the system around the model makes supervision expensive. If the agent's actions are scattered across logs, chat bubbles, browser windows, and unstaged files, then the engineer has to reconstruct causality after the fact. That is annoying for a toy refactor and unacceptable for production changes.
Antigravity 2.10.0 treats the agent as a worker that needs a proper cockpit: terminal output, Git state, MCP calls, comments, artifacts, and previews. That is the right direction. It also creates a useful product distinction. Model choice will keep changing. The durable value is the harness: permissions, context boundaries, review mechanics, tool visibility, and ways to recover when the agent gets stuck.
I would still be cautious about collapsing too much authority into one surface. A sidebar terminal and Git commit button are convenient, but they should not encourage teams to skip branch protection, CI, code owners, secret scanning, or deployment gates. The workbench should make normal engineering controls easier to apply, not replace them with trust in the session transcript.
The MCP preview work deserves particular attention. As MCP servers become the way agents touch databases, SaaS apps, cloud APIs, and internal tools, tool-call observability becomes a core security feature. I want to see every agent platform converge on structured arguments, summarized intent, formatted results, server identity, permission source, and a durable audit trail. A beautiful diff viewer is useful. A trustworthy tool-call viewer is necessary.
For teams evaluating coding agents, this release suggests a better checklist. Do not ask only which model is best this week. Ask whether the product preserves project boundaries, shows command and MCP intent clearly, separates agent edits from human edits, supports isolated worktrees, and lets reviewers leave precise feedback on artifacts. Those details decide whether agents survive contact with a real repository.
Conclusion
Google Antigravity 2.10.0 is important because it moves more of the coding-agent control loop into one inspectable workbench. The embedded terminal, Git review panel, structured MCP previews, image comments, audio attachments, and performance work are individually incremental. Together, they make the agent easier to supervise.
That is the practical frontier for coding agents in late August 2026. Better models help, but production adoption depends on harnesses that make agent work observable, bounded, reviewable, and boring enough to trust.