Overview

What FORGE is

FORGE is post-production architecture and automation. It arrives empty, learns how one studio actually works, and automates that — and only that.

The idea

Every other tool ships with opinions about how a studio should work. FORGE has none. It reads the real state of a project, detects what broke and why, fixes it, and writes down how it solved it — so the same problem never costs time twice.

The accumulation is the product. Month 3 knows what Month 1 learned. Month 12 knows what Month 6 fixed. The depth belongs to your studio, and only your studio.

What it is not

• Not a plugin. It doesn't live inside one app or one NLE.
• Not an assistant. It runs the mechanical work itself, end to end.
• Not a template. Nothing here is generic. What gets built is shaped by your pipeline.

The tools

FORGE is made of focused tools, each owning one part of the post pipeline. They share the same memory, so a fix in one is context for the next.

Overview

How it works

Five steps, always in sequence. Each one delivers something real before the next begins.

The sequence

• Audit. Maps what is broken across the pipeline.
• Diagnosis. Tells you what to fix, and in what order.
• Ingest. Encodes what was learned into the system.
• Documentation. Makes the fix permanent and readable.
• App. Executes the workflow on every future run.

Memory

Every fix is written down in plain language and stored against your studio. The next run reads it first. That is why FORGE gets deeper over time instead of resetting — you are not buying an agent configured for your studio, you are buying the configuration of an agent into your studio.

Reading a tool page

Every tool below follows the same shape, so you always know where to look:

OVERVIEW

FORGE.Audit

The Audit is where every engagement begins. Before anything is built, FORGE maps what's broken across your pipeline — and what it's costing.

What it is

The Audit is a structured diagnosis, not a sales call. You describe how your facility actually handles its footage; FORGE identifies where time is lost, what breaks, and why. It is the first of the five steps — Audit → Diagnosis → Ingest → Documentation → App — and the input to everything that follows. Nothing is built until the Audit is done.

It's also designed to stand on its own: even if you go no further, you leave with a clear, honest picture of your pipeline.

How it runs

• Questionnaire. You fill in a structured questionnaire covering your workflow end to end — ingest, conform, organisation, delivery, the team, and the storage and tools underneath it.
• Walkthrough. We go through your real jobs, not a hypothetical one, so the findings reflect how your facility works under pressure.
• Analysis. Your answers are weighed against the failure patterns we see repeatedly across post pipelines, to surface where the risk and the wasted hours actually sit.

What the report covers

You receive a written Pipeline Audit Report:

• A plain-language map of your current workflow, stage by stage
• The specific points where time is lost or work is duplicated
• Which of those FORGE addresses — and, just as clearly, which it doesn't
• A recommended starting point if you choose to proceed

What comes next

Once the Audit is signed off, Diagnosis turns the findings into a concrete plan — which tools, in what order, and the outcome to expect from each.

A real example — every Audit ranks findings by risk, so you know what's safe to change today and what's quietly costing you right now.

TOOLS · 01

Session

The single source of truth for a job — the working context every other tool resolves against.

What it is

Session pins the identity of a project in one file you own: its name, OCF roots, your house naming schema, the client, and their deliverables spec. Because relink, conform and delivery all read from it, they act on one agreed set of facts — rather than those facts being re-entered, and quietly diverging, at every stage of the pipeline.

How it runs

• Manual. You open or create a session at the head of a job and save it to disk as a .forge file.
• Reloadable. Reopen it weeks later with full context intact — OCF roots, schema, client spec — nothing reconstructed from memory.
• Authoritative downstream. Conventions are set once here; every tool that follows resolves against them automatically.

What it produces

• A portable .forge project file holding the project's identity, OCF roots, naming schema and client deliverables profile.

Where it stops

Session records and remembers — it does not touch media. It is the trusted context the other tools act on, which is exactly why it stays explicit and deliberate.

What comes next

With a session live, Relink and Conform resolve against the correct OCF roots and schema, and Deliver pre-fills from the client's deliverables spec.

TOOLS · 02

Relink

Bring an offline timeline back online in DaVinci Resolve — reviewed, not guessed.

What it is

Media moves. Cards get offloaded to new roots, originals come back from the field re-pathed, a project opens against a NAS that's been restructured — and the timeline goes red. Relink reconnects every offline clip to its real source on disk. The job a finishing assistant does by hand, clip by clip, down a media-management list, becomes a single reviewed pass.

How it runs

• Scope. Target the current timeline, selected bins, or the whole media pool.
• Resolution. FORGE determines the correct source for each offline clip and adapts to the situation — re-pathed roots, renamed files, restructured volumes — without you specifying the case.
• Dry run. Every proposed reconnection is shown before commit. Nothing touches the media pool until you approve it.
• Watch. An optional watch mode resolves media as it lands, for jobs still being offloaded.

What it produces

• Offline clips relinked to their sources, in place, in your Resolve project
• A reconnection log — what linked, what didn't, and why it was held

Where it stops

On anything less than a confident match, Relink holds the clip for a human instead of linking it. No silent mislinks, no wrong original quietly conformed into a master — the ambiguous cases come to you.

Works with

DaVinci Resolve; sources on local volumes, NAS, or returned backup drives. Runs fully deterministic — no AI, no per-clip cost — when selected in Settings.

What comes next

For sequences returning from an offline edit as AAF or XML, Conform handles the proxy-to-OCF online.

TOOLS · 03

Conform

Proxy-to-OCF online, AAF relink and interchange repair — one reviewed workflow.

What it is

The offline is cut on proxies; the online needs the original camera files. Conform ingests the editor's interchange — AAF or XML — resolves it against your OCF, and writes a conformed sequence that points the cut at the originals, ready to import into Resolve for finishing. The editor's source file is never modified. It also stands up the difficult interchanges — the ones that arrive malformed between Avid, Premiere and Resolve, with retimes, split-track audio and timecode offsets that break a naïve relink.

How it runs

• Intake. Drop the AAF or XML. FORGE parses it read-only and reports exactly what OCF it needs to come online.
• Locate. Point at your OCF root or roots, including split media across multiple volumes.
• Match. Each event is resolved to its original and presented for review — handles, reels and source timecode intact.
• Conform. A new, suffixed sequence is written alongside the original, ready to import.

What it produces

• A conformed interchange pointing at your OCF, suffixed so it never collides with the editor's original
• An optional conform report covering matched, unmatched and flagged events

Where it stops

Conform never resolves an ambiguous event silently — it surfaces the conflict and leaves the decision with the colourist or online editor. The editor's original interchange is always preserved untouched.

Handles the awkward cases

Retimes and speed ramps, split-mono audio routing, timecode offsets on tape sources, path-root remaps, proxy-to-OCF extension differences — the interchange problems that usually mean a manual rebuild are handled inside the same pass.

Works with

AAF / XML from Avid, Premiere and Resolve; OCF including ARRI, RED, Sony and DJI; DaVinci Resolve for finish. The conform is deterministic — no AI, no per-clip cost.

What comes next

Once online and imported, Vision logs and bins the material, and Deliver renders to the client's spec.

TOOLS · 04

Vision

Shot logging and metadata at the scale of a full ingest — without an assistant tagging every clip.

What it is

Vision reads your footage and logs it: location, subjects, action, framing, and whether a shot is clean, soft or unusable — then writes that back into Resolve as keyword and metadata you can actually search, filter and smart-bin against. The pass an assistant editor spends days on, watching and logging dailies clip by clip, runs across the whole pool in one go.

How it runs

• Scan. Set the scope — full media pool, selected bins, or timelines — and FORGE reads the footage.
• Review. Results come back as an editable log; anything the model wasn't sure of is flagged for your eye, not buried.
• Write. Approved metadata is written onto every instance of each clip — keywords, scene, shot, comments.
• Group. Optionally cluster the material into bins or colour-coded timeline markers by content, and identify the keeper among repeated takes.

What it produces

• Searchable, filterable metadata across the media pool — keywords, scene, shot, comments
• Optional content bins and timeline markers, and a takes-clustered view of repeated setups

Where it stops

Nothing is written until you commit. You review and correct before anything touches the project, and low-confidence reads are surfaced rather than applied. The model logs; the editorial call stays yours.

Works with — and confidentiality

DaVinci Resolve media. Vision runs on the model you choose: a local model so frames never leave the building, or a cloud model when policy allows. On the local option, no footage is transmitted anywhere — extraction and inference run on your own hardware. For embargoed productions and broadcaster security requirements, that is the difference between usable and disqualified.

What comes next

With the footage logged, Agent turns those tags into built, organised timelines and bins.

TOOLS · 05

Media

Facility-standard folder structures and offload naming — enforced the same way on every job.

What it is

Media holds your storage to a standard. It instantiates project folder trees from reusable templates, and renames camera and sound files on disk to your house naming convention — country, device, date, clip ID — so an offload lands structured and named correctly without an assistant typing names card by card.

How it runs

• Templates. Define the folder tree once; instantiate it per project with job-specific values resolved on creation.
• Rename. Bulk-rename an offload to the house schema with a live preview of every target name before a single file is touched.
• Watch. An optional watch mode picks up new folders as they're offloaded.

What it produces

• Project folder trees built to your standard structure, on disk or as Resolve bins
• Camera and sound files renamed to the house convention, in their original locations

Where it stops

Files are never overwritten and never relocated — renaming is in-place and non-destructive, and you preview every result before it runs. Original directory structure is preserved exactly.

Works with

Local volumes, NAS and field backup drives; your naming schema, country codes and device table. Naming runs on your defined rules — AI only fills the residual names a rule couldn't resolve, and disables entirely.

What comes next

Once named, Session carries the convention through the project and Relink reconnects against it without collisions.

TOOLS · 06

Agent

Drive DaVinci Resolve in plain language — and stand up an organised project from an unsorted dump.

What it is

Agent has two faces. Console drives Resolve from plain language or voice — the media-management and timeline operations you'd otherwise click through, issued as instructions. Logging takes a body of footage, inventories it deterministically, optionally reads its content, and proposes a structure of stringouts and bins — which it builds only on your approval.

How it runs

• Console. State the operation; Agent executes it in Resolve and reports back what changed.
• Inventory. Logging opens with a deterministic census — camera, source timecode, shoot dates, audio channels, resolution, and OCF-vs-proxy class — with no AI and no changes to the project.
• Enrich (optional). It can read content to deepen the inventory beyond what metadata carries.
• Propose, then build. It proposes the bin and timeline structure; nothing is created until you've reviewed and approved it.

What it produces

• Resolve operations executed from plain-language instructions
• Stringout timelines and bins built from an approved proposal
• An exportable content log (CSV), produced read-only without touching the project

Where it stops

The structure is a proposal first — nothing is built in Resolve until you approve it, and the content log exports without modifying the project at all.

Works with

DaVinci Resolve; your project's media and metadata. Inventory and build are deterministic; only the optional content-reading step uses AI.

What comes next

Agent pairs with Vision: Vision establishes what each clip *is*, Agent turns that into a built, navigable project.