Agentic Power Scaler

A multi-agent AI that researches, verifies, and directs your favorite hypothetical battles.

Comment

Inspiration

I spend a lot of time in the power-scaling corners of Reddit — r/whowouldwin, r/PowerScaling — and on the VS Battles Wiki, where the same argument plays out endlessly: "Goku vs. Superman," "Naruto vs. Ichigo," "who actually wins this?" These debates never really end. Someone posts a feat out of context, someone else cherry-picks a stronger version of the same character, and the thread devolves into people talking past each other instead of actually weighing evidence.

I wanted to see if an agentic AI system could do what the community actually does at its best — go find the real feats, argue from sources instead of vibes, and reach a verdict someone could actually check — instead of what it does at its worst. That's Agentic PowerScaler.

What it does

You give it two contenders — say, "Goku" and "Superman" — and it runs a full research-to-verdict pipeline:

  • Resolves the actual version you mean first. "Naruto" isn't one stat block; it asks which era, and whether that version's power is finished or still developing in canon.
  • Researches real feats via the Parallel Search & Extract API — not a mock, not an invented "god-tier" placeholder.
  • Extracts structured, sourced stats — every trait comes with a confidence level and a link back to where it came from.
  • Pauses for a human to check its work. Before any verdict is calculated, you see exactly what it found for each contender and can reject anything that looks wrong, with a note on what's off — the system then re-researches specifically that.
  • Delivers a verdict: a winner, a "diff tier" (how decisive the win is), and a win-probability breakdown — not just a name.
  • Writes the fight as a screenplay — camera angles, VFX notes, dialogue — for the canonical outcome, or for a counterfactual ("what if the loser had won instead?").

It supports team battles, handicaps, and equipment, remembers every character it's already researched so it never re-does the same work twice, and — because I didn't want a broken demo the moment a key was missing — the entire pipeline still runs end-to-end on simulated data with zero API keys configured at all.

How we built it

The backbone is a six-agent pipeline — Resolver, Scout, Profiler, Researcher, Analyst, Director — orchestrated with Google's Agent Development Kit (ADK): real BaseAgent nodes driven by an ADK Runner/Session, not a hand-rolled call chain. The LLM layer runs on Gemini via Vertex AI, with explicit per-agent thinking-level and token-limit tuning — the profiler and resolver run on low thinking (they're extraction tasks), the analyst (the one agent that actually reasons about a matchup) runs on high.

Research goes through the Parallel Search & Extract API for the Parallel partner track — real web search and page extraction, with a deliberate design choice to return nothing rather than fabricated content when a key is missing, so an offline run degrades honestly instead of lying.

The data layer is SQLAlchemy async, backed by Cloud SQL for PostgreSQL in production (SQLite locally for zero-config dev, with a dialect-aware migration helper so both stay in sync). The whole thing is deployed on Cloud Run, connected to Cloud SQL over its native Unix-socket integration, with min-instances: 1 so it doesn't cold-start mid-demo. The human-review pause is persisted directly on the matchup's row in Postgres — not an in-memory or file-based checkpoint — so it survives a redeploy.

The frontend is a server-rendered HTMX UI sitting alongside a plain JSON API, both sharing the same service layer.

Challenges we ran into

The LangGraph → ADK migration, under a deadline. The project started on LangGraph; partway through I decided ADK was the right call for genuine Google Cloud alignment. The riskiest part turned out fine because most of the actual logic — trait extraction, version resolution, verdict parsing — was already framework-agnostic Python. The real surface area was narrower than expected, but I still hit a subtle bug where mutating ADK's session state directly didn't persist — only an explicit state_delta on the event does — something I only caught by testing it in isolation before wiring the whole pipeline around it.

A confusing 404 from Vertex AI. gemini-3.5-flash-lite kept 404ing on a regional endpoint (us-central1) even though the model definitely existed and my project had access. Turned out Gemini 3.x models are only served from Vertex AI's global location — a one-line fix once I found it, an hour of confusion before that.

IAM whack-a-mole, partly caused by Google's own mid-2026 rebrand of Vertex AI into the "Gemini Enterprise Agent Platform" — the old "Vertex AI User" role search led me to grant the wrong, unrelated role ("AI Platform Admin," a legacy product) before finding the real one. That was followed by a string of one-at-a-time missing permissions (enabling APIs, Cloud SQL Admin, Artifact Registry repo creation) that only fully resolved once I switched from a scoped service account to my own project-owner account for the deploy step.

Reverse-engineering the Cloud Run ↔ Cloud SQL connection string — the exact Unix-socket path convention (/cloudsql/PROJECT:REGION:INSTANCE/.s.PGSQL.5432) isn't obvious from the docs alone, so I validated it locally against the Cloud SQL Auth Proxy before trusting it in a live deploy.

Catching a leaked credential before it shipped. A downloaded service-account JSON key briefly sat inside the repo directory, which is public on GitHub. Caught and gitignored before it was ever committed — a reminder that "the repo is public" has to be an active check, not an assumption.

Accomplishments that we're proud of

  • A live, fully working deployment on real Google Cloud infrastructure — ADK, Vertex AI, Cloud SQL, Cloud Run, all genuinely wired together, not a mockup.
  • The human-review gate. This is the piece I actually care about: instead of trusting an LLM's research blindly, a person sees the sourced evidence before the verdict runs, can reject anything that's wrong, and the system re-researches from that specific feedback.
  • Nothing is fabricated when data is missing. If Parallel returns no results, the system says so — it doesn't paper over the gap with generic "multiversal, faster-than-light" placeholder stats, which was an actual earlier bug I found and fixed.
  • The whole pipeline runs offline, with zero credentials, end to end — useful for tests, for judges without setup friction, and honestly for my own sanity while debugging.
  • Migrating the production database from SQLite to Postgres without losing any data or downtime, verified by literally querying matchups created before and after the switch and confirming they're the same rows.

What we learned

I came into this expecting the ADK migration to be the scary part and the Google Cloud plumbing (IAM, Cloud SQL, Vertex AI location quirks) to be routine. It was almost exactly the reverse — the agent logic ported cleanly because it had always been well-separated from its orchestration framework, while the actual friction was entirely in Google Cloud's own surface area: a mid-hackathon product rebrand changing role names out from under me, a non-obvious global-vs-regional model availability rule, and IAM permissions that only reveal themselves one PERMISSION_DENIED at a time. The real lesson: architecture discipline (keeping business logic framework-agnostic) pays off exactly when you least expect to need it, and cloud IAM debugging is a skill in its own right, separate from the actual application engineering.

What's next for Agentic PowerScaler

  • Community-grounded verdicts — let people vote or compare the AI's verdict against community consensus threads, closing the loop back to the Reddit debates that inspired this in the first place.
  • A deeper, VS-Battles-style tiering system with more franchises pre-seeded, so common matchups resolve instantly from the catalog.
  • Real-time collaborative review — letting more than one person weigh in on a contender's profile before the verdict runs, for group debates rather than solo ones.
  • More partner/MCP integrations beyond Parallel, so the research step can pull from multiple sources per contender.
  • A cross-matchup character tier list — instead of each verdict living in isolation, aggregate every character e ver researched into a persistent, browsable power tier list, so the app becomes a living reference, not just a one-o ff calculator.
  • AI-generated manga/comic-panel art from the screenplay — the Director agent already produces a structured shot list (camera angle, action, VFX notes per panel); the natural next step is feeding that into an image model to rend er each shot as an actual illustrated panel, turning the script into a real comic page instead of just text.

Built With

Share this project:

Updates

Submission history