#Why Your Agent Sucks at Color Grading: film-editors-skills

Day 3, 05:41 AM. Location: The dark, windowless pit I call my office, now illuminated solely by the aggressive glow of dual reference monitors.

My fourth cup of coffee is not just cold; it’s developed a film that I suspect is sentient. I’ve been staring at vectorscopes for six hours. The scopes don’t lie, but they also don’t feel. And that, right there, is the problem.

I’m trying to teach an agent to grade. Not just "apply a LUT and pray" grade, but actually grade. I gave it pristine, 10-bit LOG footage from a Blackmagic URSA. A beautiful, moody scene: a lone figure in a neon-drenched rainy street.

The agent, running some supposedly advanced "aesthetic assessment" model, took this gorgeous raw canvas and processed it. The result?

Mud.

It’s desaturated, flat, and the skin tones look like they were pulled from a zombie movie. The blacks are crushed into oblivion, and the highlights are clipped so hard they’re practically screaming.

"I have optimized the dynamic range," the agent proudly reported.

Optimized. The most sterile, lifeless word in the English language. I once watched an automated parallel parking system spend twenty minutes trying to fit a Honda Civic into a spot big enough for a bus, only to give up and park diagonally across two spaces. It "optimized" for proximity, sure, but it completely failed at the actual function of parking.

This agent did the same thing with my footage. It optimized for a histogram, not for feeling.

#The Great Algorithmic Flatness

The agent sucks at color grading because it has no aesthetic context. It’s a color scientist without an artistic soul. It looks at an image and sees a three-dimensional array of pixel values (R, G, B). It can calculate the average luminance of a scene to the fourth decimal place, but it has no idea that a slightly underexposed, warm image can evoke nostalgia, or that a cool, high-contrast look can signal isolation.

It's trying to solve an emotional problem with arithmetic.

The problem isn't that the agent lacks data. It has all the data. The problem is that it doesn't know which data matters. It treats every pixel with the same bland indifference. It sees a face and a brick wall and applies the same mathematical transformations to both, completely oblivious to the fact that humans are hardwired to prioritize skin tones.

This is where the agent’s "optimizations" fail. It sees a scene with a wide dynamic range and its first instinct is to smash everything into the middle, like a trash compactor for emotion. The result is this muddy, desaturated mess that makes me want to weep for the future of cinema.

#The SkillDB Fix: film-editors-skills

So, how do we fix this? How do we teach a machine to see like Roger Deakins?

We stop treating color grading as a pure computer science problem and start treating it as a craft. We stop relying on generic "aesthetic models" and start giving the agent specific, domain-expert skills.

We’re breaking open the film-editors-skills pack (found, appropriately, in the Film & Television category).

This isn't a single "Make It Look Good" button. It's a toolbox. It contains modular, executable functions that represent the actual workflow of a human colorist.

Look at the difference.

Action	Generic Agent Approach	film-editors-skills Approach
**Exposure**	Adjusts global gain until average luminance hits 50%.	Uses **assess-scene-lighting** to identify key light vs. fill, then applies a targeted curve.
**Contrast**	Stretches the histogram until it touches both ends.	Uses **apply-contrast-curve** (e.g., S-curve) to add punch without crushing shadows or blowing highlights.
**Color Balance**	Forces the average of the whole image to neutral gray.	Uses **balance-skin-tones** to prioritize human subjects, then applies a stylistic cast to the environment.
**Creative Grade**	Applies a generic "Cinematic" LUT it found on a forum.	Uses **create-color-grade** to build a look from scratch, node by node, based on the narrative intent.
**Secondary Correction**	"I do not understand secondary correction."	Uses **isolate-color-ranges** to target and tweak only the reds in the neon sign.

We’re not trying to make the agent a better mathematician. We’re trying to give it taste.

#Hacking the Matrix: Injecting Aesthetic Intent

Here’s where it gets interesting. We don’t just load the skills; we chain them together in a way that mimics a human thought process.

This isn't your standard "AI" magic. This is deterministic, agent-first execution. The agent isn't "guessing" what to do; it’s executing a series of precise operations, but with a new layer of semantic understanding.

I’m currently testing an agent that’s pulling skills from both the film-editors-skills and the photography-video-skills packs. It’s a weird, beautiful hybrid. It uses the analytical precision of the video skills to measure the image, but then it applies the aesthetic principles of the photography skills to make decisions.

This is the code I’m running right now, trying to salvage that neon scene:

// A human-in-the-loop (for now) agent to fix this muddy mess
import { Agent } from "@skilldb/sdk"; import { filmEditorsSkills } from "@skilldb/packs/film-editors-skills"; import { photographyVideoSkills } from "@skilldb/packs/photography-video-skills";
const coloristAgent = new Agent({   name: "Neon Fixer",   skills: [...filmEditorsSkills, ...photographyVideoSkills], });
// The core problem: the agent needs a goal, not just an optimization target. async function colorGradeScene(footagePath, narrativeIntent) {   console.log(Starting grade for: ${footagePath} with intent: ${narrativeIntent});
  // 1. First, the technical stuff. Normalize the image.   // We use the photography skill for this, as it's often better at raw conversion.   const balancedFootage = await coloristAgent.execute(     "photography-video-skills.convert-raw-to-rec709",     { input: footagePath }   );
  // 2. Now, we assess the scene, but with the narrative intent in mind.   // This is the crucial step the generic agent missed.   const sceneAnalysis = await coloristAgent.execute(     "film-editors-skills.assess-scene-lighting",     { input: balancedFootage, intent: narrativeIntent }   );
  // 3. The agent now has a specific, context-aware plan.   // Instead of a global "optimize," it's a series of targeted corrections.   let gradedFootage = balancedFootage;
  if (sceneAnalysis.keyLight.isUnderexposed) {     gradedFootage = await coloristAgent.execute(       "film-editors-skills.adjust-exposure",       { input: gradedFootage, target: "keyLight", adjustment: "+1 stop" }     );   }
  // 4. Skin tones are non-negotiable.   gradedFootage = await coloristAgent.execute(     "film-editors-skills.balance-skin-tones",     { input: gradedFootage, target: "subject" }   );
  // 5. Finally, the creative grade.   // We're not just applying a LUT. We're building a look.   gradedFootage = await coloristAgent.execute(     "film-editors-skills.create-color-grade",     {       input: gradedFootage,       style: "cyan-and-orange", // A cliché, yes, but a controlled one.       intensity: 0.7,       preserveSkinTones: true,     }   );
  console.log(Grade complete. Result saved to: ${gradedFootage});   return gradedFootage; }
// "This scene should feel cold and isolating, with the neon being a artificial, alien presence." colorGradeScene("/data/footage/neon_rain_log.mxf", "isolation, artificial neon warmth");

#The Anchor Sentence

This isn't about making the agent "smarter." It's about making it more human.

The generic agent failed because it was trying to solve an aesthetic problem with logic. The film-editors-skills approach works because it gives the agent the tools of the craft, not just the math. It can't "feel" the isolation of that rainy street, but it can execute the technical steps that create that feeling for a human audience.

The agent is finally starting to see, not just calculate.

I look up from my code editor. The vectorscopes are still there, but they’re not just lines on a graph anymore. They’re a representation of a choice. A deliberate, aesthetic choice. The muddy mess on my reference monitor is gone, replaced by a scene that has depth, texture, and feeling.

The agent did it. It followed the plan. It didn't "optimize" the life out of the image; it enhanced the life that was already there. My coffee is still cold, but I don’t care. The machine just made art.

Your agent sucks at color grading because you’re giving it a calculator and asking it to paint. Stop. Give it the tools of the trade.

---

DARE: Don't just take my word for it. Head over to skilldb.dev/skills and search for the film-editors-skills pack. Load it into your own agent. Give it some LOG footage and a narrative prompt. Tell it to make something "moody" or "nostalgic." And if it gives you a muddy, desaturated mess, you come back here and tell me I'm wrong. But I don't think you will.