ScriptGuard AI

The system running in production.

Inspiration

Every year, thousands of screenwriters submit scripts that never get read properly — studio "coverage" (professional script evaluation) is slow, expensive, and inaccessible to independent writers. We wanted to bring that same rigor to anyone with a script, but go further than a single generic verdict: real studios don't decide with one opinion, they argue it out in a room. So we built a room.

What it does

ScriptGuard AI simulates a studio greenlight committee. Four persona agents — Creative Producer, International Distribution, Financial Analyst, and Indie/Festival Reader — each with real industry biases, independently review a script, then react to each other's arguments in a second round: they can change their position if convinced, or push back on the strongest objection against them. A Moderator agent synthesizes the final verdict reflecting the debate's real outcome (consensus or explicit dissent), not an average.

Before the debate, two agents research the market concurrently via Parallel's Search API — pulling real box-office comparables and genre trends — so the committee argues with actual data, not guesses. After the verdict, a self-critique loop audits every claim in the report against that research and automatically revises anything unsupported before it ships.

You can also upload a full slate of scripts at once. Each gets its own committee, and a "Head of Acquisitions" agent then prioritizes the slate as a portfolio — flagging genre diversification, budget balance, and cannibalization risk between similarly-toned projects.

How we built it

The pipeline is orchestrated entirely with Google ADK: 17 agents coordinated through 1 SequentialAgent, 3 ParallelAgent, and 1 LoopAgent. All agents run on Gemini via google-genai. Market research uses the official Parallel SDK (parallel-web) as a real tool called at runtime, not just referenced. The interface is Streamlit; PDF scripts are parsed with pypdf; all inter-agent state is validated with Pydantic schemas.

We iterated the architecture twice before landing here: the first version was a flat 4-step sequential pipeline producing one generic verdict — functional, but indistinguishable from any other "AI script coverage" tool. We rebuilt it around real debate (two parallel rounds instead of one pass), added the self-critique loop so the system checks its own claims against evidence instead of trusting the LLM blindly, and added slate-level prioritization for the actual use case of an acquisitions team, not an isolated read.

Challenges we ran into

ADK doesn't reliably support combining tool use with structured output (output_schema) on the same LlmAgent except on Gemini 3.0, so agents that call tools write free text and a separate formatter agent (no tools) converts that into Pydantic-validated JSON.

We also hit a Windows-specific asyncio issue: closing and reopening an event loop on every Streamlit click triggered a cosmetic "Fatal error on SSL transport" traceback when destroying async HTTP clients mid-use. We fixed it by reusing a single event loop across every run in the process.

Validating cost and latency was also a real concern for a public demo. Testing has been limited to 4-page scripts so far — an individual script completes in ~35 seconds — with feature-length behavior left untested by design choice, not a technical limitation: only the ScriptAnalystAgent receives the script's full text, so runtime should scale far more slowly than script length, but we haven't burned a paid key to confirm that on a full screenplay. A slate of 3 scripts completed in 1 minute 22 seconds and correctly surfaced real committee dissent — in one script's debate, two of the four committee members changed position in round two and ended up dissenting from the official verdict — plus a genuine cannibalization risk flagged between two similarly-toned scripts in the slate ranking.