Setting Agent Edges

In an AI-assisted pipeline, you must distinguish between the burden and the art. The burden consists of the repetitive, high-volume production paperwork—updating scene breakdowns, tracking prop lists, or cross-referencing shot logs. This is where proactive agents, such as OpenAI's Dots or Anthropic's Claude Duet, provide the most value by automating the grind. The art, however, is the creative decision-making: the specific phrasing of a line, the timing of a performance, or the visual composition of a frame.

For example, if a script change adds a set of keys to scene forty-two, you assign a Dots agent to the burden: it scans the scene breakdown and adds 'House Keys' to the prop list for that scene. You do not give it the authority to touch the art; it is strictly forbidden from rewriting the dialogue to explain why the keys are there. That decision remains with the writer and director. By separating these two, you ensure that the machine handles the logistics while the humans retain absolute control over the creative intent of the film.

To prevent an AI agent from making silent, unauthorized changes to your production, you must define its edges. Edges are the precise boundaries that dictate when an agent acts and where its authority ends. Without these, a proactive agent might interpret a vague instruction as permission to overwrite approved work. Every agent you deploy must have four specific edges: a trigger (what wakes it), permissions (what it may change), restrictions (what it must never touch), and an escalation path (whom it asks for help).

Consider a Claude Duet agent managed by a post supervisor. You define its edges as follows: it is triggered to wake only when a new script page is uploaded to the shared folder. Its permission is limited to updating the shot list to reflect new scene numbers. Its restriction is a hard line: it must never touch the approved take logs, as those represent locked performances. Finally, its escalation path is the Post Supervisor; if the agent finds a conflict between the new page and a locked take, it pauses and sends a notification for human confirmation. By configuring these edges, you transform a broad tool into a disciplined team member with a known remit.

While edges define the boundaries of an agent's behavior, a remit defines the scope of its authority. Think of a remit as a professional job description for the AI. It specifies exactly which production areas the agent is responsible for and, crucially, where its authority stops. Without a clear remit, an agent might attempt to solve a problem by overstepping into another department's domain, leading to contradictory plans that you only discover during a review.

For example, you might assign a planning agent the remit to identify scheduling conflicts. If a rewrite moves a specific action from scene forty-two to scene forty-four, the agent is authorized to scan the schedule and flag that the necessary equipment is no longer available for that time slot. However, its remit does not include the authority to reschedule the shoot. It cannot move the shoot date to accommodate the change; it can only report the conflict. As a producer or supervisor, you use the remit to ensure the agent identifies the problem (the burden) without making a high-stakes decision (the art) on its own.

A hard line is an explicit, non-negotiable prohibition that an agent must never cross, regardless of how a prompt is phrased or how urgent a task seems. While a remit defines what an agent should do, a hard line defines what it is forbidden from doing. In a high-pressure production environment, AI can suffer from 'drift,' where it begins to offer solutions that overstep its authority—such as rewriting a line of dialogue to fit a new shot length—under the guise of being helpful. To prevent this, you must program a hard line into the agent's core instructions.

Consider a 'writing partner' agent used by a director to brainstorm. You grant it the authority to suggest ideas for a missing emotional beat in scene forty-two, such as suggesting that Nora should look at the house keys before speaking. However, you set a hard line: the agent is strictly forbidden from writing actual script lines. It can provide bullet points of ideas, but it cannot generate dialogue. As a lead, you implement this by explicitly stating in the agent's configuration: 'Under no circumstances shall you output formatted screenplay dialogue.' This ensures the AI remains a collaborator for ideas without accidentally replacing the writer's voice.

A proactive agent is always 'listening,' but it should not always be acting. If an agent activates on every minor file save or chat message, it risks creating a noise loop or, worse, performing silent overwrites of your production data based on a draft that wasn't meant for the whole team. To prevent this, you must configure a specific trigger—the exact event that 'wakes' the agent and authorizes it to begin its task.

For example, in a fast-moving production, you might receive various script drafts, notes, and ideas in a shared folder. You do not want your breakdown agent updating the official prop list every time a writer saves a rough sketch. Instead, you configure the trigger to wake only when a PDF explicitly labeled 'Blue Pages' is uploaded to the production folder. 'Blue Pages' are industry-standard signals for revised script pages. By tying the agent to this specific file naming convention, you ensure the AI only acts on official, approved revisions. As a lead, you define these triggers to ensure that automation only happens at the exact moment the production requires it, keeping the pipeline stable and predictable.

The most dangerous failure in an agentic pipeline is the 'automated guess.' This happens when an agent encounters contradictory data and, instead of pausing, chooses the most probable solution to keep the process moving. In film production, a probable guess can lead to a continuity error that is only discovered after the render queue, where it becomes incredibly expensive to fix. To prevent this, you must program a strict escalation path. This tells the agent that whenever it finds a conflict—such as a script requirement that contradicts a locked performance—it must immediately stop all work on that sequence and route a question to a specific human lead.

For example, imagine a planning agent reviewing take logs for scene forty-two. It notices that the script now requires Nora to hold a set of keys, but the locked 'hero take' (take six) shows her hands are empty. An unguided AI might guess that you want to digitally add the keys in post-production. A bounded agent, however, triggers its escalation path: it pauses the update and sends a notification to the Director: 'Conflict in scene 42, take 6: script requires keys, but take shows empty hands. How to proceed?' As a lead, you use escalation to ensure the machine identifies the gap, but the human makes the call.

The greatest risk of an agentic pipeline is not a technical glitch, but human complacency. When an AI consistently handles the burden correctly, teams stop checking the work and start taking the pipeline for granted. This creates a dangerous blind spot: if the agent fails or misinterprets a revision, the error may travel silently through the conform, grade, and mix, only to be discovered on the day of delivery. To prevent this, you must treat your pipeline as a system that needs regular stress-testing. You do not assume the edges are holding; you prove they are.

For example, you can test a Dots pipeline by intentionally introducing a 'poison pill'—a script draft that is incorrectly dated or a duplicate version of a page. If the agent is bounded correctly, it should not quietly overwrite the current production baseline. Instead, it must pause, flag the date discrepancy, and ask for human verification. As a lead, you implement 'fail-on-purpose' drills. By forcing the agent to stop, you remind your team that the AI is a tool for identification, not a final authority. You ensure that the final sign-off always remains a human act.