Building an Agent-Native After Effects Workflow

2026-09-12

A reference architecture developed through short-form video production, externalising After Effects state for AI-assisted motion design under human direction.

artistic-system-building creative-identity-system structural-legibility short-form-video first-principles

Reference architecture for AI-assisted art direction, motion design and creative production

Why Creative Production Needs Explicit State

Art direction, design systems, motion identity, series production, campaign consistency, editorial design, brand systems and visual language all depend on the same difficult requirement: individual outputs need to change without allowing the system that connects them to drift.

Mainstream AI creative tools are extremely useful when a visual system can be selected, prompted or adapted from abstractions the platform already provides, when generated output can move progressively towards a finished artefact, and when broad variation is itself useful.

This workflow is aimed at a different case.

Production origin: the zombie-survival short-form series

This architecture grew out of producing the TikTok Zombie Survival Series for the wider How to Stop ChatGPT From Lying investigation.

The analytical argument concerned language-model failure. Producing the short-form videos exposed a different problem: every episode needed to inherit a stable visual identity while its wording, imagery, duration, timing and composition changed. After Effects builds also needed to support scripted reconstruction, rendered-frame inspection and continued manual refinement without losing approved work elsewhere in the system.

Those production pressures produced the workflow described here. The zombie-survival series is its implementation origin rather than its permanent subject; this article generalises the resulting method for other repeatable motion-design systems.

+----------------------------------------------------------+
| DEFINE rather than SELECT                                |
|                                                          |
| The visual system itself has to be authored rather than  |
| chosen from a template, preset or existing abstraction.  |
+----------------------------------------------------------+
                         |
                         v
+----------------------------------------------------------+
| INTERMEDIATE rather than FINAL                           |
|                                                          |
| AI output can be one stage in a longer professional      |
| creative process rather than the finished artefact.      |
+----------------------------------------------------------+
                         |
                         v
+----------------------------------------------------------+
| CONTROLLED VARIATION rather than DRIFT                   |
|                                                          |
| Selected dimensions should change while the identity of  |
| the wider visual system remains stable.                  |
+----------------------------------------------------------+

The central idea is:

Move consequential creative-production state out of the opaque After Effects project and into explicit, inspectable and version-controlled representations that an AI agent can reason over, modify, rebuild and verify without becoming the final creative authority.

This requires a distinction between a generator and an agent.

A generative model produces candidate material: text, images, motion or other assets.

An agent operates at the level of the production system: it reads current state, preserves constraints, selects operations, invokes tools and evaluates the resulting evidence.

GENERATOR
produces candidate material
        |
        v
AGENT
maintains and transforms production state
        |
        v
PROFESSIONAL APPLICATIONS
execute specialised operations

Generation can therefore occur inside the workflow without organising the workflow.

From “same style” to a design system

Generative AI is exceptionally strong at variation. Its weakness is often maintaining a tightly controlled identity while varying only selected dimensions.

The creative requirement is rarely just:

Make another variation.

It is more often:

Change these dimensions while preserving those dimensions.

A design system makes that distinction explicit.

CREATIVE SYSTEM
|
+-- INVARIANT
|   +-- typography
|   +-- hierarchy
|   +-- framing
|   +-- colour relationships
|   +-- motion grammar
|   +-- transition behaviour
|
+-- VARIABLE
|   +-- imagery
|   +-- wording
|   +-- subject matter
|   +-- pacing
|   +-- composition subtype
|
+-- EXCEPTIONS
    +-- deliberate hierarchy breaks
    +-- one-off compositions
    +-- manually refined sequences
    +-- intentional rule-breaking

For motion design, identity is not only visual. It also includes behaviour: how type enters, how long information holds, how elements accelerate, how compositions transition, how imagery is revealed, and when the system deliberately breaks its own rules.

That is why After Effects matters here. The goal is not simply to produce outputs that look broadly similar. It is to preserve a visual and behavioural grammar while allowing individual pieces to differ.

AI output does not have to be final

Many commercial generative systems become more valuable as their output becomes closer to final:

prompt
  |
  v
better generation
  |
  v
less manual intervention
  |
  v
finished artefact

That is useful for many tasks, but professional creative production often needs another relationship:

agent-generated structure
          +
manual refinement
          +
continued automation

Human intervention is not evidence that automation failed. It can be part of the workflow by design.

The system can automate repetitive assembly, alignment, timing propagation, asset placement, validation and reconstruction while leaving composition, taste, visual judgement, timing nuance, one-off effects and deliberate rule-breaking open to manual intervention.

The important constraint is that generated and manually edited state must remain distinguishable. Manual edits made inside explicitly rebuildable generated compositions may still be overwritten, so those ownership boundaries need to be clear.

This changes the correction model.

GENERATIVE WORKFLOW

90% correct artefact
       |
       v
request small change
       |
       v
regenerate
       |
       +-- requested property changes
       +-- unrelated successful properties may drift

AGENT-NATIVE WORKFLOW

90% correct production state
       |
       v
identify responsible layer
       |
       v
change that layer
       |
       v
preserve everything else

That is where explicit production state becomes creatively useful rather than merely technically tidy.

What the Agent-Native Workflow Contains

An ordinary After Effects project concentrates a great deal of meaning inside the application itself:

After Effects project
        |
        +-- compositions
        +-- layers
        +-- timing
        +-- imported assets
        +-- effects
        +-- expressions
        +-- manual edits
        +-- application state
        |
        v
      .aep

For a human editor, much of that state is visible or inferable through the interface. For an AI agent, it is comparatively opaque.

A GUI agent can click through the application, but that does not mean it has a reliable representation of which decisions are approved, which values may change, which assets are authoritative, or what can safely be rebuilt.

The workflow therefore places explicit project state between human intent, the agent and After Effects.

                  HUMAN
                    |
              intent / approval
                    v
          +---------------------+
          | EXPLICIT PROJECT    |
          |       STATE         |
          +---------------------+
               ^           |
               |           |
          observation   execution
               |           |
             AGENT         v
                       AFTER EFFECTS
                            |
                            v
                     rendered evidence
                            |
                            +----------> AGENT

The agent works primarily on machine-readable production state. After Effects remains the professional execution and rendering environment.

The distinction can be summarised as follows:

Dimension	Typical AI creative platform	Agent-native After Effects workflow
Project state	Mostly application-internal	Consequential state externalised
AI role	Generate or edit content	Maintain and transform production state
Application role	Authoritative workspace	Professional execution environment
Variation	Often prompt-driven	Explicit invariants, variables and exceptions
Correction	Edit or regenerate	Correct the responsible state
Verification	User views result	Rendered evidence is part of the loop
Agent hand-off	Often session-dependent	Recoverable from project state

This does not make the workflow universally superior. For a one-off social graphic, rapid layout or standardised asset, a mainstream tool will often be faster and simpler.

The advantage appears when the work depends on a bespoke system that has to survive repeated production, revision, exception and manual refinement.

State ownership and authority

The workflow is safest when every consequential decision has an explicit owner and a corresponding form of evidence.

State	Controls	Agent authority	Verification
Editorial content	Wording and sequence	Editable within the approved brief	Content and schema validation
Style configuration	Visual invariants and repeatable rules	Change only when directed	Render comparison
Asset manifest	Approved assets and assignments	Assign and validate declared assets	Manifest and file checks
Timeline	Timing, pacing and slide order	Revise after timing review	Duration and sequence checks
After Effects build	Generated application state	Rebuild through scripts	Script completion
Rendered frames	Actual visual output	Inspect rather than treat as configuration	Human and agent visual review
Manual compositions	Exceptions and accumulated craft	Preserve unless explicitly directed	Human approval

The pipeline

The workflow treats production as a sequence of explicit state transformations:

source material
      |
      v
semantic / editorial planning
      |
      v
content + slide structure
      |
      v
audio alignment
      |
      v
timeline + visual configuration + assets
      |
      v
scripted After Effects build
      |
      v
rendered reference frames
      |
      v
inspection
      |
      v
correct responsible state
      |
      +--------------------> rebuild / approve

Model-derived audio alignment is provisional evidence. It becomes approved production timing only after review and explicit adoption into the timeline JSON.

The operating loop is:

DEFINE -> BUILD -> OBSERVE -> CORRECT

A successful script is not proof that the visual result is correct.

script completion = structural evidence
rendered frame     = visual evidence

After Effects is still a stateful desktop application. Modal dialogs, scripting permissions, active-project state, plugin differences and application-level failures still need to be managed. Externalising production state does not make After Effects deterministic; it makes the important parts of the production easier to inspect, rebuild and diagnose.

How the Production Architecture Works

The repository is the reference implementation of this architecture.

It keeps the important production layers separately inspectable:

after-effects-agent-native-production-architecture/
|
+-- README.md
+-- CONTRIBUTING.md
|
+-- docs/
|   +-- operating rules, dependencies and known failures
|
+-- examples/
|   +-- reusable brief and public-safe case-study material
|
+-- template/
|   +-- project.json and PROJECT_STATUS.md
|   +-- content/          editorial and semantic state
|   +-- design/           visual direction and repeatable rules
|   +-- assets/           approved assets and asset manifest
|   +-- audio/            narration and timing evidence
|   +-- after_effects/    timeline, slide state and build scripts
|   +-- quality_control/  rendered evidence and visual review
|   +-- thumbnail/        source, configuration and iteration state
|   +-- delivery/         exports and publication metadata
|
+-- tools/
    +-- project creation, alignment and validation

The Git boundary is deliberate. Scripts, configuration and documentation are versioned; Adobe project files, media, model weights and generated frames remain outside version control.

A few files show the pattern particularly clearly:

template/design/style_config.json makes repeatable visual rules machine-readable.
template/assets/asset_manifest.json separates asset generation from asset approval.
template/after_effects/ae_scripts/04_export_reference_frames.jsx turns actual After Effects output into visual evidence.

The full file structure, schemas, scripts, operating rules and implementation details belong in the repository itself rather than being duplicated here.

Inspect the After Effects Agent-Native Production Architecture on GitHub

Using it with an agent

The repository is not itself an AI agent. It is the environment and operating protocol an external coding agent works against.

The interaction model is short:

agent reads repository
      |
      v
agent reconstructs current state
      |
      v
human specifies desired change
      |
      v
agent changes the responsible explicit state
      |
      v
build / validation runs
      |
      v
rendered evidence returns
      |
      v
human / agent evaluates
      |
      v
local correction
      |
      +--------------------> repeat

Agent operating rules

The operating contract is:

READ CURRENT STATE
      |
      v
IDENTIFY THE RESPONSIBLE REPRESENTATION
      |
      v
PRESERVE APPROVED INVARIANTS
      |
      v
CHANGE THE SMALLEST RESPONSIBLE INPUT
      |
      v
REBUILD
      |
      v
INSPECT RENDERED EVIDENCE
      |
      v
RECORD APPROVAL OR CORRECT

The agent should therefore:

inspect current project state before changing anything;
identify which representation owns the requested change;
preserve approved invariants and human-owned exceptions;
alter the smallest responsible input;
rebuild through the declared tooling;
inspect actual rendered evidence; and
record approval or correct the responsible state.

The detailed operating rules live in the repository so they can persist beyond any one article, agent or conversation.

How This Workflow Relates to Decrepit Filth

This workflow occupies the point where the site's structural research becomes a repeatable creative-production system.

Content Strategy defines the visual language, media and production direction that the workflow can preserve.
How AI, Network Analysis and LLMs Reveal Hidden Structure in Content explains why the quality of an explicit representation determines what a system can inspect and act upon.
Workflow Structure Breakdown provides a parallel staged model in which evidence is transformed through explicit, human-supervised states.
From SEO Keywords to the Haunted Machine shows how structural research became a creative operating system; this workflow carries that systems logic into production.
Maximising Artistic Identity preserves the earlier proposal to combine After Effects, procedural tools and physical media into a distinctive visual language.

These are functional relationships rather than claims that each page describes the same workflow. Together they connect representation, research, creative direction, implementation and rendered evidence.

What This Changes for Creative Practice

Making the production system explicit produces several concrete advantages.

Portable production logic. Visual rules, editorial structure, timing logic, asset assignments and operating constraints can travel with the project rather than existing only inside one .aep, one workstation or one editor's memory.

Recoverable agent hand-offs. A new agent can reconstruct consequential current state from the repository instead of depending on the complete history of a previous conversation.

Replaceable models. A speech model, image generator or language model can be replaced without redefining the production architecture. Models provide capabilities; they do not own the project.

Localised corrections. Content, timing, asset, visual-system and build errors can be traced to the representation responsible for them rather than forcing broad regeneration.

Accumulated manual craft. Human refinement can remain part of the production while automation continues elsewhere, provided generated and manual ownership boundaries are respected.

Continued use of professional applications. After Effects, Photoshop and other specialist tools do not have to be replaced by simplified AI-native substitutes. The agent participates in the production environment rather than requiring the production environment to be redesigned around the agent.

That is the broader distinction.

AI CREATIVE PLATFORM

complexity
   |
   v
hide it behind a simpler creative interface

AGENT-NATIVE PROFESSIONAL WORKFLOW

complexity
   |
   v
make the consequential parts explicit
   |
   v
let an agent reason over them

If the creative abstractions a platform already provides are sufficient, the mainstream tool is likely to be faster and easier.

If the work instead requires constructing, preserving and progressively refining its own art direction, motion identity, design system, campaign logic, editorial grammar or visual language, then the production system itself becomes part of the creative work.

The architecture can be reduced to one sequence:

DEFINE THE SYSTEM
      |
      v
EXTERNALISE ITS CONSEQUENTIAL STATE
      |
      v
LET THE AGENT OPERATE ON THAT STATE
      |
      v
EXECUTE THROUGH PROFESSIONAL TOOLS
      |
      v
OBSERVE THE REAL OUTPUT
      |
      v
CORRECT WITHOUT LOSING THE SYSTEM

The goal is not to replace art direction with generation, or professional software with a prompt interface.

It is to let AI participate in professional creative practice without requiring the practice to be simplified around AI.