On September 24, 2026, Google announced Bring Your Own Agent — BYOA — for Android Studio on the Android Developers Blog. The one-line summary:

Last year they opened up model choice. This year they opened up the agent itself.

Even if you don't write Android apps, this announcement deserves your attention. IDEs are moving from shipping their own agents to letting you plug in whichever agent you want.

What exactly is BYOA?

Starting with the Rabbit 2 Canary preview, three agents ship built in: Google Antigravity, Claude Agent, and Codex. Any agent speaking ACP (Agent Client Protocol) can be registered, via the agent registry at Settings > Tools > AI > Agents.

Connecting one is refreshingly ordinary:

1. Update to the latest Android Studio on the Canary channel
2. Pick an agent in the agent window (Claude Agent / Codex / Antigravity)
3. Sign in with the plan you already use, or enter an API key

Drawn as a picture, the shift looks like this:

Old IDE
Developer → built-in Gemini agent → code changes

After BYOA
Developer → chosen agent (Claude / Codex / Antigravity)
          → Android Studio project info + build & run tools
          → code changes → build & test → review → revise

Google's claimed benefits sit right on that diagram. The agent receives the Android project graph, build configuration, and platform details, so it works more accurately — and when a chat stalls, it continues with IDE tools directly. If one agent runs out of quota or its output disappoints, another agent can take over. On pricing, you bring whatever plan you already pay for, so personal and corporate plans mix freely.

The Gemini path stays. Using built-in Gemini as the onboard agent remains, and anyone wanting the newest Gemini models plus bigger quotas is pointed at the Antigravity agent. Latest-model access like Gemini Flash 3.8, Google AI Pro or Ultra sign-in, and token-based billing on Gemini API keys live on that side. Organizations on Gemini Enterprise keep their Google Cloud security and privacy terms on either agent, according to Google.

This didn't drop out of nowhere

BYOA extends a shift that started early this year, as Agent Mode steadily gained permissions and verification features. The pieces make sense together.

In January, Otter 3 added Bring Your Own Model: connect outside models from Anthropic, OpenAI, and others via API endpoint and key. Looked at now, everything else in that release was a verification-loop part:

- A changes drawer grouping edited files (per-file keep & revert)
- On-device deploy with screenshot and Logcat checks, adb shell input control
- Remote MCP server connections (Figma, Notion, and friends)
- Journey tests written in plain language (Journeys)

In July, Quail 2 added parallel conversations: one tab refactoring UI, another fixing ProGuard, another writing docs — all running at once. It shipped with a warning that touching the same file can collide, plus a tidy connection that sends App Quality Insights crashes straight into agent chat for Fix with AI.

Explicit permission controls over actions like file edits also landed in Agent Mode. Auto-approve exists, but the defaults lean toward humans reviewing first. Repository-level instruction files like AGENTS.md belong to the same current: stop re-explaining rules in chat, write them down in the repo.

The direction is fairly clear:

Code editor
→
Agent runtime
(repo context + tools + permissions + verification loop)

Why verification loops matter more than IDE shortcuts

Your edge is shifting from knowing IDE shortcuts to giving an agent repo context, tools, permissions, and a verification loop. Here's the concrete reason.

Getting an agent to edit code is ordinary now. The gap opens after the edit: does the build pass, do tests stay green, does the failure log feed the next instruction automatically, does a risky command pause for approval? When that loop lives inside the IDE, you just wait for results. When it lives outside, you fill the gaps with copy-paste.

Fast agent + manual verification
→ Humans review more as the agent goes faster

Average agent + automatic verification loop
→ Humans just read results and approve

So reading the BYOA announcement as "Android Studio now allows outside agents" catches only half of it. The other half: the IDE itself is turning from a code editor into the runtime where agents run. Whichever agent you choose, the IDE supplies project info, build and run tools, permissions, and the verification loop.

Related posts

References

What to do this weekend: count your project's verification loops

You don't need to write Android apps to act on this. Answer these questions for the project you use today:

1. Can you see all agent-edited files in one place?
2. Can you revert file by file?
3. Do build / test run automatically?
4. Does the failure log feed the next instruction automatically?
5. Does a risky command pause for approval?
6. Does the repo hold a rules file? (AGENTS.md, CLAUDE.md, etc.)

Missing even one or two means the agent speeds up while you grow anxious. Filling these six gaps beats switching IDEs. Try telling your agent "fix this build error" and watch: does it fix, build, and re-fix hands-free? Projects where that loop runs feel completely different from projects where it doesn't.

Go deeper with a course

If you want hands-on practice delegating work to agents while keeping verification and permissions in place, a structured course walks you through it.