Antigravity releases updates every two to three weeks, and the April–May 2026 cycle included several changes that affect daily development workflow. Here's what actually changed and what it means in practice.
IDE v1.22.2 — Manager View and Editor View
The most visible UI change in recent releases is the separation of the agent interface into two distinct views.
Manager View is for monitoring. It shows the task queue, execution logs, and real-time progress across all running agents. When an agent is working on a long task — or when you're running parallel agents — this is the view you use to see what's happening without interrupting the work.
Editor View is for code. It's a cleaner, more traditional code editing interface without the agent conversation mixed in. You can read and edit code while an agent is still running, something that was awkward before when the conversation UI and file content were competing for the same space.
Keyboard shortcuts for switching views:
macOS: Cmd+Shift+M (Manager) / Cmd+Shift+E (Editor)
Windows/Linux: Ctrl+Shift+M / Ctrl+Shift+E
In practice, the split solves a real friction point: previously, if an agent was running a long build or test cycle, checking on the code meant navigating through the agent conversation. Now you keep Manager open in one pane and Editor in another and they stay independent.
Parallel Agent Improvements
Parallel agents — running multiple agent instances simultaneously on different parts of a project — have been available for a while, but the April update meaningfully improved reliability.
File conflict detection: When two agents try to write to the same file simultaneously, the system now detects the conflict and serializes the writes rather than producing corrupted output. Before this update, parallel work on overlapping files occasionally resulted in partial writes.
Progress visibility in Manager View: Each running agent now shows which file it's currently working on, making it practical to actually monitor parallel work without guessing which agent is doing what.
Independent failure handling: If one agent in a parallel session encounters an error and stops, the others continue running. Previously, one failed agent could stall the entire session.
A practical workflow this enables: running a test-writing agent and a feature-implementation agent simultaneously on separate modules. The parallelization actually saves time for projects where tests and implementation are cleanly separable.
AGENTS.md Support
You can now place an AGENTS.md file in your project root to define project-specific agent behavior — similar to how CLAUDE.md works in Claude Code.
# AGENTS.md — Project-specific agent configuration
## Technology rules for this project
- Use Jest + @testing-library/react for all tests (not Vitest)
- Styling is Tailwind only — no styled-components
- API clients belong in src/lib/api/
- New components require a Storybook story
## Avoid
- TypeScript `any` types — handle errors explicitly
- console.log in committed code
- Hardcoded environment variables (use .env)
## Architecture notes
- This is a Next.js App Router project, not Pages Router
- Server Components are preferred; use Client Components only when needed
- Database access happens only in server actions or API routesThe value of AGENTS.md is that these constraints persist across sessions without you having to re-state them. Every time an agent picks up work on the project, it reads the file and follows the rules automatically. If you've been repeating the same instructions at the start of every session ("remember to write tests," "don't use any types"), AGENTS.md is the place to write them once.
Auto-continue Now Default On
The Auto-continue setting — which allows agents to proceed through multi-step tasks without pausing for confirmation — is now enabled by default for new users.
For experienced Antigravity users, this is probably the right default: most of the time, you want the agent to keep going. The main risk is early in a new project when you haven't established trust in the agent's direction and want to catch wrong assumptions before they compound.
Settings > Agent > Auto-continue: Toggle on/off
If you're new to Antigravity, consider disabling Auto-continue for the first week. Seeing each decision point explicitly helps calibrate your understanding of how the agent reasons before you hand it full autonomy.
Quota Changes
The April update included practical quota relaxations for Pro plan users, though Antigravity doesn't publish exact numbers. Based on what's been reported in the developer community:
- Daily agent execution time limits expanded
- Credit consumption for background tasks reduced
- Rate limiting on long-running tasks (30+ minutes) relaxed
The practical effect: the scenario where a large refactoring task would exhaust your daily quota mid-session is less common now. Credit-heavy workflows are more viable at Pro tier than they were three months ago.
Ultra Plan Added
A new plan tier arrived in April:
Free: limited credits (resets monthly)
Pro: ~$20/month — standard credits + premium models
Ultra: $249.99/month — high-volume credits + priority support + team features
Ultra is clearly targeted at teams and heavy professional use. For solo indie developers, Pro still covers most use cases. The exception is if you're running long autonomous sessions daily — the kind of work that would previously require careful credit management. At Ultra, that concern largely goes away.
AgentKit 2.0 Integration Updates
The integration between Antigravity and AgentKit 2.0 (the multi-agent orchestration layer) received several reliability improvements:
- Agent-to-Agent (A2A) protocol connections to external agents are more stable
- Context sharing between agents is faster
- Automatic fallback when an agent in a multi-agent pipeline fails
The A2A protocol integration is still worth a dedicated deep-dive — for now, the summary is that connecting Antigravity agents to external services and other agents works more reliably than it did in the previous quarter.
For related integration patterns, the Antigravity Cloudflare AI Gateway integration guide covers how to route agent traffic through Cloudflare for caching and observability.
What's Worth Trying First
If you haven't explored recent updates yet, these are the two changes that are most likely to improve your daily workflow:
1. AGENTS.md — Takes about 15 minutes to set up for a project you work on regularly, saves time every session afterward. Write down the constraints you find yourself repeating.
2. Manager View + parallel agents — If you have a project where testing and implementation are clearly separable, try running both in parallel with Manager View open to monitor progress. The stability improvements make this practical in a way it wasn't before.
The quota relaxations and Auto-continue change are also worth noting, but they're passive — they improve the experience without requiring any action on your part.
The Bigger Picture: Where Antigravity Is Heading
Looking at the direction of these updates together, a pattern is clear: Antigravity is moving from a "single agent with good autocomplete" model toward a "fleet of agents you supervise" model. The Manager/Editor split, parallel agent stability, and AGENTS.md are all infrastructure for that shift.
The UI changes make it practical to have agents working in the background while you're focused on different parts of the codebase. AGENTS.md makes those agents project-aware without constant prompting. The quota changes make longer autonomous sessions economically viable.
This is worth thinking about if you're deciding how to integrate Antigravity into your workflow. The tool is optimized for "define the task, let it run, review the output" rather than "type code and get completion suggestions." That's a different usage pattern than Cursor or GitHub Copilot, and it produces the most value when the tasks you give it are clearly specified and long enough to benefit from autonomous execution.
A coding assistant that's good at one-line completions and an autonomous agent that can build an entire feature are distinct tools. Antigravity's recent updates are making it more of the latter — which means the developers who get the most out of it are increasingly those who are comfortable writing detailed task descriptions and reviewing work rather than guiding each step interactively.