ReleasePilot

• 

  Deterministic PR updates only versionCode and versionName, creating a reviewable GitHub release branch and pull request.

• 

  Planning workflow showing inspection complete, plan ready for review, and execution gated behind explicit confirmation.

• 

  Immutable audit trail with ordered workflow events, timestamps, and stage transitions for transparent release planning.

• 

  ReleasePilot system architecture: Cloud Run, FastAPI, ADK, Firestore, Secret Manager, Safe Executor, and Verifier.

• 

  Operator workspace for grounded planning, evidence review, and safe release coordination across the workflow.

Inspiration

Android releases involve the same high-risk, repetitive steps again and again: inspect the repository, determine the correct version change, edit build files, create a branch and pull request, and then verify that nothing unintended changed.

I built ReleasePilot to turn that process into an agentic workflow without giving an AI model unrestricted write access to a repository.

What it does

ReleasePilot takes an Android GitHub repository through a controlled release workflow:

• Inspects the real repository and extracts Android release metadata
• Creates a grounded release plan from observed repository facts
• Keeps all GitHub writes behind explicit confirmation
• Enforces an exact repository allowlist and stale-base protection
• Applies deterministic versionCode and versionName changes
• Creates a dedicated release branch and pull request
• Never modifies or merges the main branch directly
• Independently re-reads GitHub and verifies the resulting pull request
• Persists workflow state and an ordered audit trail in Firestore

The deployed control center makes the workflow visible as:

Inspect → Plan → Execute → Verify

How we built it

ReleasePilot is built in Python with Google ADK and Gemini 3.5 Flash for agentic reasoning and tool orchestration.

The web control center uses FastAPI and runs on Google Cloud Run. Firestore stores persistent workflow state, revisions, and ordered audit events. Secret Manager and IAM protect runtime credentials.

GitHub operations are performed through bounded tools. Repository inspection and verification are read-only, while mutations are protected by deterministic Python safety checks including explicit execution intent, repository allowlisting, stale base-SHA validation, and restricted version-file edits.

Challenges we ran into

The biggest challenge was not making an AI change a version number—it was designing a system that could take useful action without giving the model unrestricted authority over a repository.

We had to separate agentic reasoning from deterministic safety controls. ReleasePilot needed to inspect real GitHub state, avoid guessing missing facts, detect stale base commits, restrict writes to an exact allowlist, make only narrowly scoped Gradle version edits, and independently verify the resulting pull request.

We also worked through practical integration challenges involving GitHub permissions, persistent Firestore workflow state, Cloud Run deployment, service identity, Secret Manager, and reliable Android Gradle metadata inspection.

Accomplishments that we're proud of

We built an end-to-end agentic Android release workflow that works against a real GitHub repository.

ReleasePilot can inspect an Android project, create a grounded release plan, enforce a human confirmation boundary, make deterministic version changes on a dedicated branch, create a real pull request, and independently verify the result.

We are especially proud that the system never writes directly to main and never merges a pull request. Every workflow is also persisted in Firestore as an ordered audit trail, making the agent's actions transparent and reviewable.

The final system is deployed on Google Cloud Run and uses Google ADK and Gemini 3.5 Flash for reasoning over real repository evidence.

What we learned

The most important lesson was that agentic reasoning and execution authority should be separated.

Gemini is effective at interpreting intent, selecting tools, and reasoning over repository evidence, while deterministic code is better suited for enforcing invariants such as authorization, repository allowlisting, stale-base checks, version mutation rules, and branch safety.

We also learned that independent verification is critical for trustworthy agents. Instead of trusting the result of its own execution, ReleasePilot performs a separate read-only GitHub pass to verify what actually changed.

Persistent workflow state and audit events also make an agent much easier to understand, debug, and trust.

What's next for ReleasePilot

Next, we would extend ReleasePilot while preserving the same safety model.

Potential improvements include richer CI and test-result integration, configurable release policies, authenticated multi-user teams, additional Android release checks, changelog generation, and support for more complex multi-module projects.

A future version could also integrate with app-store release workflows after a pull request has been reviewed and approved.

The core principle would remain unchanged: agentic reasoning can propose and coordinate actions, but sensitive mutations must stay behind explicit authorization, deterministic safety controls, and independent verification.

Built With

• android
• cloudrun
• fastapi
• gemini3.5flash
• githubapi
• google-cloud
• googleadk
• gradle
• iam
• python
• secretmanager