BACKLOT

Agentic AI production crew that turns screenplays into grounded schedules, budgets, risk reports, resources, and production-ready packages.

Comment

Inspiration

Film pre-production is a chain of interconnected decisions involving specialized roles: script breakdown, scheduling, budgeting, risk analysis, resource planning, and final approval.

I was inspired by a straightforward question:
What if an AI production crew could handle this complex workflow together instead of asking a single AI assistant to do everything?

I wanted to build a system that could create a production plan, challenge its own decisions, detect problems, dynamically re-plan, demonstrate where its numbers came from, and know precisely when a human should make the final call.

That idea became BACKLOT.

What it does

BACKLOT is an agentic AI production crew that transforms a screenplay into a production-ready plan through a structured workflow:

$$\text{Screenplay} \rightarrow \text{Breakdown} \rightarrow \text{Schedule} \rightarrow \text{Budget} \rightarrow \text{Risk Review} \rightarrow \text{Re-plan} \rightarrow \text{Human Approval} \rightarrow \text{Resources} \rightarrow \text{Production Package}$$

Each agent performs a specialized role:

  • Script Supervisor: Breaks down the screenplay into granular elements.
  • 1st AD Scheduler: Generates a deterministic shooting schedule.
  • Budget Agent: Calculates costs using grounded production data via MCP.
  • Risk Agent: Critically evaluates the plan and requests a re-plan if necessary.
  • Approval Gate: Puts final budget decisions directly in the producer's hands.
  • Resource Agent: Proposes specific production resources following approval.
  • Package Assembler: Compiles the complete, final production package.

The core highlight of the architecture is the Risk $\rightarrow$ Re-plan loop. When a serious issue is detected, BACKLOT updates the relevant constraints and executes another planning cycle. To prevent infinite loops, the system features fixed-point detection and a hard limit on planning passes.

How we built it

I built BACKLOT using Gemini and the Google Agent Development Kit (ADK), orchestrated by a custom coordinator.

LLMs are used strategically where qualitative reasoning adds value. Components like the Scheduler, Approval Gate, and Package Assembler run on deterministic logic, while Gemini handles tasks requiring nuanced understanding—such as screenplay analysis, risk assessment, budgeting, and resource selection.

Key Architectural Highlights

  • Typed Communication: Agents pass strictly typed Pydantic artifacts rather than bloated conversation transcripts.
  • Data Integration: The Budget and Resource agents interface with external data using the Model Context Protocol (MCP) via an mcp-clickhouse server integration. Granular tool filtering controls database permissions per agent.
  • Structured Provenance: Values grounded in external data carry source records, while ungrounded values are explicitly flagged rather than presented as absolute facts.
  • Full-Stack Implementation: Built with Python, FastAPI, and Uvicorn on the backend, a responsive HTML/CSS/JS frontend, fully containerized via Docker, and deployed publicly.

Challenges we ran into

Building BACKLOT as a solo developer required tackling challenges across every layer of the stack:

  1. Bounded Autonomous Behavior: To avoid erratic re-planning or endless retries, I combined deterministic scheduling, constrained delta adjustments, fixed-point detection, and capped LLM invocations.
  2. Schema and Structured Output Errors: Optional fields in the Risk Agent’s output schema initially broke constrained generation within ADK. I diagnosed the schema issue, refactored the design, and introduced regression tests to guarantee output stability.
  3. MCP Dependency Conflicts: A version mismatch between Google ADK and mcp-clickhouse was resolved by isolating the MCP server into its own environment and process, establishing clean security and runtime boundaries.
  4. Deployment Constraints: Operating without paid cloud credits, I deployed the public demo on Render's free tier. I designed a dual-mode data system: a lightweight dataset-backed mode for the free public demo and the full ClickHouse/MCP pipeline for local/resource-rich environments.

Accomplishments that we're proud of

I am proud that BACKLOT is an architectural system, not just a set of chained prompts:

  • Specialized Agent Roles: True task separation across discrete agents.
  • Hybrid Architecture: Deterministic constraint solving paired with generative reasoning.
  • Adversarial Evaluation: A dedicated Risk Agent empowered to reject unsafe or unviable plans.
  • Self-Correction: A diagnosis-driven, bounded re-planning loop.
  • Human-in-the-Loop: An explicit approval gate prior to resource allocation.
  • Grounded Transparency: MCP-backed data access with explicit uncertainty markers for missing information.
  • Software Rigor: Typed Pydantic contracts and automated unit/integration tests spanning schemas, control flow, grounding, and UI rendering.

Core Design Principle: An AI system should always be able to explain what it knows, what it doesn't know, and why it arrived at a decision.

What we learned

Building BACKLOT was a transformational learning experience.

Prior to this project, I had never built a full-scale application using Gemini or agentic frameworks. I gained hands-on expertise in structuring multi-agent orchestration, handling structured output schemas, and managing production API integrations.

More importantly, it taught me engineering resilience. Debugging multi-agent race conditions, schema misconfigurations, and dependency conflicts reinforced the value of methodical root-cause analysis over quick fixes. I learned how to carefully balance AI reasoning with deterministic control to build predictable, trustworthy software.

What's next for BACKLOT

  • Enhanced Operations: Expand into active production planning, including real-world calendars, actor/location availability, and equipment constraints.
  • Third-Party Integrations: Connect directly with standard industry production-management software.
  • Multimodal Intelligence: Evolve BACKLOT into a multimodal production crew capable of reasoning across visual storyboards, audio cues, script text, and financial ledgers—while keeping human creators in total control.

Built With

Share this project:

Updates

Submission history