ContinuityOS

AI-powered production continuity control that detects schedule conflicts, traces cascading impacts, proposes explainable resolutions, gets human approval, and verifies the change.

Comment

Inspiration

Film production is a coordination problem disguised as a creative process. A single change to a scene can affect the schedule, cast, location, weather requirements, continuity, and everything that depends on them.

We were inspired by the idea of treating production continuity like a live dependency system rather than a collection of disconnected spreadsheets and documents.

For our Project Nightfall scenario, we created a realistic conflict around Scene 42: the script requires night rain at Warehouse 09, while the schedule places the scene outdoors at 10:00 AM. The location opens at 18:00, and Sarah Vale is unavailable until 19:00.

Instead of simply flagging the conflict, we wanted AI agents to investigate why it exists, understand what else it affects, propose alternatives, and help a human make the final decision.

That became ContinuityOS.

What it does

ContinuityOS is an agentic production control system that detects continuity conflicts and turns them into explainable decisions.

It can:

  • Detect conflicts between script, schedule, cast, and location constraints.
  • Retrieve and evaluate supporting evidence.
  • Trace cascading effects across dependent records.
  • Build an understandable impact graph.
  • Generate multiple possible resolutions.
  • Compare the relative impact of those resolutions.
  • Keep a human decision-maker in control.
  • Verify the production state after an approved change.
  • Maintain an auditable decision trail.

The core workflow is:

Detect → Investigate → Trace Impact → Generate Solutions → Approve → Verify

Instead of asking, "What went wrong?", ContinuityOS helps answer:

"What changed, what does it affect, what can we do, and did the fix actually work?"

How we built it

We built ContinuityOS with a lightweight frontend and a FastAPI backend.

The system is organized around specialized agent responsibilities:

  • Supervisor Agent — coordinates the investigation.
  • Script Agent — understands scene requirements.
  • Schedule Agent — checks timing and scheduling constraints.
  • Cast Agent — evaluates availability.
  • Location Agent — checks location constraints.
  • Continuity Agent — identifies continuity conflicts.
  • Impact Agent — traces downstream consequences.
  • Resolution Agent — proposes alternative fixes.
  • Verification Agent — validates the final state.

The backend exposes a clean API boundary and keeps external AI and retrieval integrations server-side.

For reliable development and demonstration, we also designed deterministic local evidence and fallback behavior so the core workflow can operate without depending entirely on external credentials.

The data layer supports SQLite for zero-configuration local development and PostgreSQL for production deployment. Database changes are managed through Alembic migrations, while Docker provides a path toward reproducible deployment.

The interface was intentionally designed as a production command center rather than a generic chatbot. Instead of hiding the reasoning behind a conversation, it exposes evidence, dependencies, impact, proposed resolutions, approval, and verification.

Challenges we ran into

The biggest challenge was making a multi-agent system both technically meaningful and easy to understand.

Simply displaying multiple AI agents does not make a system useful. We needed each stage to have a clear responsibility and produce information that the next stage could actually use.

Another challenge was handling cascading dependencies.

A schedule conflict may initially look like one problem, but changing the schedule can affect cast availability, location availability, weather requirements, and downstream scenes. We therefore had to model the problem as a connected system rather than a single validation check.

We also had to balance AI capabilities with reliability. External AI and retrieval services can be unavailable, so the system needed controlled fallback behavior rather than failing completely.

Finally, we wanted AI to assist with decisions without silently making production changes. This led us to build explicit human approval and post-change verification into the core workflow.

Accomplishments that we're proud of

We are proud that ContinuityOS goes beyond simply detecting a conflict.

It creates a complete decision loop:

Conflict → Evidence → Dependency Graph → Impact Analysis → Resolution Options → Human Approval → Verification

We are especially proud of the Scene 42 demonstration because a seemingly simple scheduling mismatch becomes a connected investigation across multiple production constraints.

We also built the architecture with production deployment in mind rather than treating the project as a frontend-only prototype.

The system includes:

  • FastAPI API architecture
  • Agent-oriented workflow design
  • Dependency and impact tracing
  • Human-in-the-loop approval
  • Verification after changes
  • SQLite development support
  • PostgreSQL production support
  • Alembic migrations
  • Docker deployment support
  • Server-side integration boundaries
  • Deterministic fallback behavior
  • Testable API boundaries

Most importantly, we built around a principle we believe matters for real-world agentic systems:

AI can recommend the decision, but the human remains accountable for the decision.

What we learned

We learned that building an agentic application is less about connecting an LLM to a prompt and more about designing the system around the model.

Good agents need:

  • Clear responsibilities
  • Structured evidence
  • Reliable state
  • Well-defined boundaries
  • Explainable outputs
  • Controlled actions
  • Human oversight
  • Verification

We also learned that verification is just as important as generation.

An AI system can produce a convincing recommendation, but that does not mean the recommended change actually solved the underlying problem.

This changed how we approached ContinuityOS: instead of ending when an AI produces an answer, our workflow ends only after the approved resolution has been checked.

What's next for ContinuityOS

ContinuityOS is designed to evolve from a prototype into a real production intelligence layer.

Next, we want to add:

  • Live production-management integrations
  • Deeper Gemini-powered agent reasoning
  • Real-time schedule monitoring
  • Weather and location intelligence
  • Cost and delay estimation
  • More sophisticated dependency graphs
  • Historical decision analysis
  • Production-wide risk prediction
  • Richer audit and accountability features
  • Automated monitoring after approved changes

Our long-term vision is to make ContinuityOS a continuous control layer for complex productions.

Instead of discovering problems after they create delays and costs, production teams could see conflicts and their potential ripple effects before they become expensive problems.

ContinuityOS turns production continuity from reactive firefighting into proactive, explainable decision-making.

Built With

Share this project:

Updates

Submission history