Scriptsculpt

Scriptsculpt transforms screenplay revisions into a production-imaoct report, helping creative and technical teams understand what changed, who is affected and, what needs attention next.

Comment

Inspiration

I got my inspiration from the underlying issues which some of friends who are editors and, who specializes in film making faces as well as what other production lead and sub-department faces; the urge and drive to build was entirely in the phase. One, to solve the script revison problem which my frineds faces while freelancing, making movies, editing scenes, going back to back in the endless loop of figuring out what caused or may have caused scenes not to be acted to be well after scripts were put out, why scripts hinder the development and production of movies and, trying to atleast cure in the aspect they do find sleepless nights in.

And, for the second phase, it was about the real production management, movie specialist, film creators who makes movies for world use cases; of course, everyone would except a movie is well acted right out and, in doubt fufilling to their sight and, taste they paid in cinemas for. So, for a movie to be acted out, script ought to be rightly put out, figured out early if they dont exactly play out well or fit the imagination of a production team. And, it's well believed production teams always hope and pray their job gets easier, which of course script revisioning is one core factor of that.

Hence, why i decied to build Scriptsculpt after multiple researching of problems faced in the cinematic and entertainment world.

What it does

It accepts scripts from production leads/managers and output a revised version of it; ScriptSculpt is built wholeheartedly for the purpose of comparing between two scripts used in a cinema production for film creation and detecting flaws which after then, it then proffer recommendations to be used for this script provided to ensure producers figure out production mistake early and ensure, film creation is faster.

It eases the manual hassles of producting teams or producing specialised to look at texts and try figure what's wrong - Scriptsculpt just handles this task simply by tackling the flaws, analyzing it and checking within the text which department is affected, what effect could it have in production, what risk could the outcome of a bad script have in a movie production, how a bad script could temporarily halt the production of movies if no precise flaw is detected before or after acted out and/or what negative effect could it contribute such as a bad script permanently leading to the a movie not being produced or made as a result of a bad script and also, preserving the "health check" of a producer or an editor if a script flaws decides to be roughly put out or badly written.

Just as sculptor craves beautiful things out of woods, SciptSculpt carves well thought-out recommended solutions for flawed scripts.

How I built it

I began by researching the different challenges faced during film production, particularly the problems created when a screenplay changes between drafts. I explored how writers, editors, script supervisors, producers, and department leads manage revisions and discovered that even a small script change can affect sound, continuity, props, costumes, locations, scheduling, and other production decisions.

Rather than building a general-purpose screenplay editor, I focused on a specific problem: helping production teams understand not only what changed between two screenplay versions, but also what those changes mean for the production. This became the foundation for ScriptSculpt.

I then designed a workflow around two screenplay versions:

Upload or enter the original screenplay.

Upload or enter the revised screenplay.

Compare both versions.

Identify meaningful changes.

Analyze sound-continuity risks and affected departments.

Generate practical recommendations for human review.

After defining the workflow, I built the agent architecture with Google’s Agent Development Kit; A coordinator agent delegates tasks to specialized agents: one compares the screenplay versions, another evaluates sound and continuity risks, and another identifies affected production departments. This allowed me to divide a complex analysis into focused responsibilities rather than relying on one general response.

I then tested the agents locally, refined their instructions, added structured outputs, and debugged issues involving imports, dependencies, authentication, and deployment. I then deployed the backend to Google Cloud Run so that the agent could be accessed through an API.

Finally, I used Replit Agent to build the interactive web application around the backend. Replit helped me turn the workflow into a complete user experience, including the upload interface, sample input, analysis process, results display, and film-inspired visual design.

Throughout the process, I iterated based on testing. When the first outputs were too brief or exposed raw JSON, I improved the agent instructions and redesigned how results were presented. This helped me move from a basic script-comparison tool toward a more useful production-impact assistant.

ScriptSculpt was built through a combination of problem research, workflow design, agent development, cloud deployment, interface experimentation, and continuous testing. My goal was to create a tool that helps filmmaking teams keep up with screenplay revisions and make sure important production changes do not get overlooked.

Challenges I ran into

1. Module Name Conflict & Circular Loop

** Issue*: ImportError: cannot import name 'app' from 'agent' **Root Cause: Having both an agent.py file and an agent/ folder in the same root workspace confused Python's namespace. In addition, the orchestrator script tried to import app before it was fully loaded. * Solution**: Moved agent.py and utils.py completely inside the agent/ subfolder package. Configured agent/__init__.py to handle the exposure cleanly using a relative path: from .agent import app.

2. Broken Package Tracking Context

Issue: ImportError: attempted relative import with no known parent package Root Cause: Executing application sub-files directly as separate backend scripts stripped Python of its parent package execution mapping context. Solution: Adjusted execution structure to always launch the core engine from the root project directory via module entrypoints.

3. Redundant Absolute Workspace Imports

Issue: ModuleNotFoundError: No module named 'multi_tool_agent' Root Cause: Business logic scripts were attempting to import utilities using the full path prefix (from multi_tool_agent.agent.utils import ...) while already operating natively inside that folder directory context. Solution: Truncated the import strings across backend files to resolve relative paths directly: from agent.utils import contains_keyword.

4. Invalid Framework Import Path

Issue: ImportError: cannot import name 'App' from 'google.adk.agents' Root Cause: Sourcing the main Google ADK orchestrator App object from the standard .agents library block where it doesn't live. Solution: Corrected the target source path statement in agent/agent.py: from google.adk.apps.app import App.

5. Incorrect FastAPI Initialization Signature

Issue: TypeError: get_fast_api_app() got an unexpected keyword argument 'agents' Root Cause: Manually passing a hardcoded array list signature containing active worker agents into an orchestration wrapper designed exclusively for directory-level parsing. Solution: Changed the configuration variables to pass a directory path hook pointer instead: get_fast_api_app(agents_dir=AGENT_DIR, web=True).

6. Missing Interface Mounting Reference

Issue: AttributeError: 'App' object has no attribute 'interface' Root Cause: Attempting to manually bind a custom .interface() route block layer onto a metadata storage class while get_fast_api_app(..., web=True) already constructs the whole interface under the hood. Solution: Removed manual .mount() reference hooks entirely from server.py and passed complete control over to the ADK discovery manager module.

7. 429 RESOURCE_EXHAUSTED — quota limit: 0 on gemini-3.1-pro

Cause: Not a "used up your quota" error — limit: 0 means the free API tier has zero allowance for Pro-tier models. Pro-tier generally isn't available on the free key at all; only Flash-tier models have free quota. Fix: Switched target model to a free-tier-eligible Flash model (gemini-2.5-flash / gemini-2.0-flash) instead of gemini-3.1-pro. Flash is also the more practical choice for this task (department classification, sound-continuity checks) — faster and cheaper, and avoids repeatedly hitting the quota wall during dev/demo.

Accomplishments that i'm proud of

Built a functional multi-agent AI system using Google ADK that compares screenplay revisions and identifies production impacts.

Deployed the agent on Google Cloud Run with Vertex AI integration, satisfying the hackathon's Google Cloud requirement.

Self-debugged a docker issue(first time) on google cloud build and eventually dpeloy via a service on google cloud run.

Quickly understood the deployment pipeline of a web service/api on google cloud at first time use.

Created a clean, film-industry-inspired UI in Replit which inlduded white/gold typography, purple-black background, and orbital animation.

Implemented a clear user flow: upload two script versions → analyze → receive structured comparison, sound risks, and actionable recommendations.

Integrated department impact classification to help production teams (Sound, Camera, Art, etc.) understand downstream effects of script changes.

Successfully connected the Replit frontend to the deployed ADK backend via API.

What I learned

Google ADK architecture: How to build multi-agent systems with sub-agents, tools, and context caching.

Cloud Run deployment: The process of containerizing and deploying AI agents on Google Cloud, including environment variables and service accounts.

API integration: How to connect a Replit frontend to a Cloud Run backend using REST APIs.

Prompt engineering: The importance of clear, structured instructions for agents to produce human-readable output instead of raw JSON.

Film production workflow: Real pain points filmmakers face when comparing script revisions, including sound continuity, department coordination, and change tracking.

Debugging deployment issues: Resolved ASGI app errors, billing activation challenges, and API enablement problems.

Design thinking: implemneted an aesthetically pleasing deisgn which i did integrated from figma community and also, align perfectly well with the agent workflow; this also enable user to easily understand first hand, how to use the application and how it works.

What's next for ScriptSculpt

Department badges: Visual tags showing which production departments are affected by each change.

Longer script support: Optimize for feature-length screenplays (90+ pages) with chunking and pagination.

Team collaboration: Enable multiple users to comment on and discuss script changes within the platform.

Integration with production tools: Connect to industry software like Final Draft, Celtx, or StudioBinder for seamless workflow.

Sound continuity deep-dive: Expand the sound agent to identify ADR needs, wild track requirements, and playback considerations.

**Script Comparison for Videos files: expand the range of comparison for scriptsculpt to be able to detect speech flaws, missed out words from scripts intended to be used in production of movies and just only text-script-comparison.

Mobile-responsive design: Ensure the interface works smoothly on tablets and phones for on-set use.

Built With

Share this project:

Updates

Submission history