Terminal, Git and MCP: Antigravity 2.10 Shows Where AI IDEs Are Heading
Google Antigravity 2.10 isn’t a spectacular release because it adds one unexpected feature. It matters because it brings several normal development actions into the same agent space: running commands, inspecting diffs, staging files for commit, confirming changes, reviewing tool calls, and attaching richer context.
That’s the real direction of the market.
The agentic IDE looks less and less like “a chat next to the editor” and more and more like an operations center for shipping software.
Google’s official changelog for Antigravity 2.10.0, published on August 24, 2026, summarizes the headline as: “Embedded Terminals, Git Version Control, and Audio Attachments”. The short version is that Antigravity now incorporates an embedded terminal in the sidebar, native Git controls in the Review panel, richer views for MCP and custom tool executions, comments on image regions, audio attachments, and several performance improvements.
None of those features is conceptually exotic. That’s precisely why the release is interesting.
The Agent Surface Is Absorbing the SDLC Cycle
For years, development tools were organized into separate surfaces:
- The editor for writing code.
- The terminal for running commands.
- Git interface or CLI for reviewing and confirming changes.
- The browser for documentation, issues, and previews.
- Chat for AI assistance.
- CI for validation.
Code agents started attaching to one or two of those surfaces. First they lived inside the editor. Then they moved to the terminal. Then they started opening files, applying patches, reading documentation, running tests, calling tools, and generating artifacts.
Antigravity 2.10 is another step in the consolidation phase.
The embedded terminal lets you run builds, test suites, and scripts without switching applications. Git controls let you inspect diffs of the working tree, stage and unstage files, and create commits from the Review panel. MCP and custom tool execution steps now show structured headers, expandable argument blocks, and formatted result previews.
That combination matters more than any single point alone.
When the agent can propose code, run the command that validates it, show the diff, expose evidence of tool calls, and let the person commit from the same interface, the IDE stops being merely the place where you edit code. It becomes a control plane for development work.
Why Git Inside the Agent Interface Matters
Git integration is especially important because it defines the handoff between agent autonomy and human accountability.
A code agent can generate a patch. But the developer still has to answer practical questions:
- What changed?
- Is the change well-scoped?
- Did the agent touch files that didn’t belong?
- Can I stage only part of the work?
- Should this become a commit now or does it need another validation pass?
By putting Git review controls directly into the agent flow, Antigravity reduces the distance between “the model did something” and “I understand what’s about to enter the repository”.
That’s the part that matters for teams.
The bottleneck in agentic coding isn’t just code generation quality. It’s reviewability. If an agent can work fast but the person can’t clearly inspect, separate, reject, or confirm changes, the flow still feels unsafe. Native Git controls make the cycle more legible.
This also brings Antigravity into workflow territory occupied by tools like Cursor, Claude Code, Codex-style agents, and terminal-first projects like OpenCode. The competitive question stops being just “which model wrote the better function?” and becomes “which surface gives the developer better operational control over the agent’s work?”.
The Terminal Completes the Build-Test-Review Cycle
The embedded terminal is the other big piece.
A serious flow with code agents needs command execution. You can’t evaluate most non-trivial changes just by reading the patch. You need tests, type checks, linters, build scripts, migrations, dev servers, package commands, and sometimes small diagnostic commands.
If the terminal lives outside the agent environment, the flow fragments. The developer asks the agent to change code, switches applications, runs tests, copies the result back, requests a fix, reviews the diff elsewhere, and repeats.
It works. But it’s not elegant.
With terminal execution and Git review inside the same interface, the cycle becomes more compact:
- Ask the agent to make a change.
- Run the relevant command.
- Inspect the failure or success.
- Review the diff.
- Stage the right files.
- Commit or request another iteration.
That’s the cycle every AI coding environment is trying to capture.
For yoDEV readers, especially teams evaluating AI dev tools beyond the demo, the practical question is this: does the tool reduce context switching while preserving human review, or does it hide complexity behind a chat box?
Antigravity 2.10 is clearly moving toward the first answer.
MCP Previews Are Not Cosmetic
Improvements to MCP and custom tool previews might sound like interface polish, but they point to another critical layer: observability of tool calls.
As agents call more external tools, developers need to see what happened. Which tool was invoked? With what arguments? What did it return? Did the result come back structured, truncated, formatted, or ambiguous?
Antigravity 2.10 improves those execution steps with structured headers, expandable argument blocks, and formatted result previews. That matters because MCP is becoming part of the agentic development stack. Agents are no longer limited to editing files and running shell commands. When connected, they can query issue trackers, documentation, databases, observability tools, design files, and internal services.
The more tools an agent can call, the more the interface needs to expose evidence.
A hidden tool call is hard to trust. A visible, inspectable call becomes part of the review trail.
That’s why the “agentic IDE as control plane” framing is useful. The control plane isn’t just about giving orders. It’s also about observability, review, permissions, and recovery.
Audio and Image Region Comments Expand Context Around Code
Audio attachments and image region comments are less central to the software delivery cycle, but they’re part of the same story.
Antigravity now lets you attach audio files as MP3, WAV, M4A, AAC, OGG, FLAC, and OPUS up to 20 MB. It also lets you select regions and leave comments directly on images in the file viewer.
That means the agent workspace is absorbing more forms of input: voice notes, UI captures, design references, visual bug recordings, diagrams, and visual feedback. For product and engineering teams, that matters because many code tasks don’t start as perfectly written tickets. They start as “this part of the UI feels off”, “this is what the user recorded”, or “compare this screenshot with the expected state”.The more naturally those inputs enter the agent’s workspace, the less translation work falls on the developer.
Still, this is the zone where teams need to be careful. Richer inputs are useful, but they also increase the amount of context that might contain private product, customer, or internal process information. Flows with audio and images need the same governance attention as access to code and repositories.
The warning: consolidation can also become lock-in
The strategic advantage of this direction is clear: fewer surfaces, tighter cycles, better review, and fewer context switches.
The risk is also clear.
When an agentic IDE controls terminal execution, Git review, tool calls, previews, attachments, comments, and artifact flows, it becomes a very powerful default environment. That can improve productivity, but it also increases switching costs. Teams should evaluate not just the model experience, but also the operational boundaries:
- Can developers clearly review each change made by the agent?
- Are tool calls visible enough to audit and debug?
- Can the team maintain their existing Git discipline?
- Does the flow degrade gracefully if the agent fails?
- Are permissions and connected tools understandable?
- Can the work be reproduced outside the IDE?
These questions matter more as agentic IDEs become central to daily development.
A highly polished agent surface that hides too much is not a productivity tool. It’s a governance problem waiting to happen.
The biggest signal
Antigravity 2.10 is a product release, but the underlying signal runs through the entire industry.
AI coding tools are converging on the same thesis: the future interface for building software won’t be just an editor, or just a terminal, or just a chat. It will be a workspace where the agent can act, the developer can inspect, and the team can maintain control over the delivery process.
That’s why terminal, Git, and MCP previews belong in the same conversation.
The terminal gives execution.
Git gives accountability.
MCP gives scope.
The agent interface unites them.
For developers in Latin America who are choosing their AI coding stack in 2026, I’d use this lens. Don’t just ask which tool writes better code in a benchmark. Ask which tool gives your team the cleanest cycle from intention to implementation, validation, and review.
Antigravity 2.10 is Google’s most recent answer to that question.