Ross

Inspiration

The idea started somewhere else entirely. My first instinct was to repurpose an existing project of mine, a ledger forensics agent built to catch financial anomalies, and just point it at box-office data instead. It felt like a shortcut: working code, a proven architecture, just a new domain.

Then I actually read the official rules closely and hit a wall: "New Projects Only." No submission may be a modification or extension of prior work. That rule killed the shortcut, but it also forced a better question: instead of what can I reuse, what does a writers' room actually need that nobody's building?

That reframe led to the real inspiration. Script continuity and fact-checking are both things a human is supposed to catch, but nobody actually holds an entire script in their head at once. A prop that contradicts itself between scene 3 and scene 5, or a historical detail that's just wrong, slips through because catching it requires either perfect memory or stopping to research mid-flow. That's a problem an agent with a full-context window and live web search is genuinely suited to solve, not just automate.

The name came from the same place: Mike Ross, from Suits, whose entire value came from an eidetic memory, holding every case and precedent in his head and catching contradictions nobody else could see because they weren't reading everything simultaneously. That's the mechanism, almost exactly.

What it does

Ross reads a full script and runs two layers of checking at once:

1. Internal consistency: holding the entire script in context, it catches continuity errors invisible to a scene-by-scene read: props, injuries, wardrobe, timeline, geography, and what each character actually knows at a given point in the story.
2. External verification: for claims that depend on the real world (historical accuracy, technical facts, period details), it queries the web via Parallel's Search API and returns a cited verdict, explicitly flagging when sources disagree rather than silently picking one. The output isn't a one-time PDF report. It's a living, per-scene issue list a writers' room can triage, resolve, dismiss, and re-check as the script goes through revisions.

How we built it

The architecture split along a hard constraint from the rules: the agent core had to run entirely on Google Cloud AI tooling (Gemini + ADK), which is Python-first by Google's own recommendation. Rather than fight that, the design isolates the agent core to Python behind a clean internal API boundary, while the frontend and API layer stay in TypeScript, keeping most of the actual surface area in the stack I'm most comfortable shipping fast in.

For the Parallel integration specifically, we went back and forth on two valid approaches: native Gemini Grounding (lighter, built-in) versus explicit tool calls via the parallel-web SDK (more control, and the only path that supports Parallel's Extract and Task APIs for deeper multi-source cross-referencing). We landed on starting with native Grounding to get a working core fast, then layering in explicit Search/Extract/Task calls once the base loop was solid, so the conflict-detection feature ("three sources confirm, one archive disputes") could actually happen instead of staying a nice idea on paper.

(This section should be updated with what actually happened during the build: specific tools, libraries, and decisions that changed once code was written.)

Challenges we ran into

The biggest challenge wasn't technical, it was scoping. The first version of this idea (script in, one Parallel search per claim, report out) is the obvious read of what Parallel's Search API does, and in a hackathon with thousands of participants, "obvious" is a real risk: multiple teams will likely build something structurally similar. Getting honest feedback on that early forced a redesign toward two cheap-but-meaningful upgrades: internal consistency reasoning (which costs zero extra API calls, just better use of context) and deeper source cross-referencing (which uses Parallel's Extract/Task APIs, not just Search), instead of one expensive UI overhaul that wouldn't have moved the needle as much.

(Update with real build challenges: bugs, API quirks, context-window limits on long scripts, anything that broke.)

What we learned

That the rules of a hackathon are worth reading closely before committing to an approach. The "New Projects Only" clause changed the entire direction of the project, and reading it early saved a wasted week rather than a wasted afternoon. Also that the cheapest improvements to an idea are often reasoning and scope changes, not new infrastructure: the internal consistency layer added real differentiation without adding a single new API dependency.

What's next for Ross

Multimodal fact-checking is the natural next layer: extending verification beyond text to VFX concept art and mood boards, checking them against real-world reference images via Gemini's multimodal grounding. That's explicitly scoped as a stretch goal rather than core, so it only gets built if there's time left after the core loop is solid.

Built With

• cloud-run
• gemini
• gemini-grounding
• google-agent-development-kit
• google-cloud
• google-genai
• node.js
• parallel
• parallel-extract-api
• parallel-search-api
• parallel-task-api
• pdf-parsing
• python
• react
• rest-api
• secret-manager
• typescript
• vertex-ai
• vertex-ai-agent-engine