World-Class Motion Graphics in After Effects: the process

Work through the shared foundations, follow the relevant mode, then finish with QA and delivery:

Part A – Connect to After Effects. Establish reliable control of your own AE instance.
Part B – Rules that always apply. Read the shared animation and editability rules before building.
Part C – RECREATE process. Match a reference through analysis, measurement and comparison.
Part D – CREATE process. Develop an original film through research, concept, story and build.
Part E – Finish. Verify the final render and package the requested deliverables.

Working modes

Mode	Goal	How it starts
RECREATE	Match a reference video 1:1 in timing, layout, motion and look, rebuilt natively.	Analyse and measure the reference; it defines the story.
CREATE	Make an original film for a brand or product.	Research, concept, story and moodboard, followed by building.

Part A – Connect to After Effects

The goal is a private, reliable, scriptable After Effects instance that no other agent can disturb, and that you can drive without touching the GUI.

A1. Launch your own instance

Record the running AE PIDs: pgrep -f "Contents/MacOS/After Effects".
Launch a new instance:
```
open -n "/Applications/Adobe After Effects 2026/Adobe After Effects 2026.app" --args -m
```
A small Swift launcher (NSWorkspace.openApplication with createsNewApplicationInstance=true and args -m -ApplePersistenceIgnoreState YES) can do the same thing and return the PID directly.
- Do not start the raw binary through subprocess.Popen. That process is not bundle-registered and cannot receive AppleEvents.
Diff the PID lists and retain the new PID for subsequent commands.
- AE may re-spawn under a new PID after startup. Take the PID that owns the "Adobe After Effects" main window (Quartz CGWindowListCopyWindowInfo).
- The bundle id is com.adobe.AfterEffects.application.
Clear the start-up dialogs (Crash Repair → Continue). An Adobe sign-in window in these instances is a known display glitch: ignore it, never enter credentials, and don't escalate it to the user.
ensure_ae.py automates all of this: it relaunches when the PID is dead, confirms the small dialogs, detects the respawned PID, and reopens the project.

A2. Talk to it by PID only

tell application "Adobe After Effects 2026" hits any instance, including other agents' instances. Never use it.
aedo (Swift) sends the AppleEvent misc/dosc (DoScript) to one PID.
ae.py script.jsx or ae.py -e "code" wraps every script:
- includes the ES3 JSON polyfill (json.jsx);
- calls app.beginSuppressDialogs();
- runs $.evalFile inside try/catch;
- writes {ok, value, error, line, file, ms} to a result file. AppleEvent return values are unreliable, so always read the file.
Project-identity guard: before any mutating script, verify the target PID and app.project.file against the project being edited. Never close or quit an instance you have not verified is yours.
Run one AE script at a time. Scripts are often not idempotent, so back up or Save As before bulk changes.

A3. Health check before real work

With one script, read back:

app.version and whether the project is yours;
the comp renderer (ADBE Advanced 3d is needed for 3D Model layers and environment lights);
fonts: app.fonts.getFontsByPostScriptName(name).length must be greater than 0 for every font you plan to use;
that a test saveFrameToPng appears on disk.

Also set the preference that lets scripts write files and access the network (Pref_SCRIPTING_FILE_NETWORK_SECURITY).

A4. The build pipeline: data → native project

Use available build helpers or implement equivalents; the helper names below describe their roles.

Python describes the film as data. A kit.py DSL provides:
- K() sparse keys with named eases;
- shape, text, precomp, null, camera, model, L (layers);
- effects by matchName, masks, track mattes, expressions, markers, notes, labels.
Combine scene specifications into a single build specification.
kit.jsx builds native layers from the spec.
- It creates layers bottom-up, so they are already in the final order. Avoid mass reordering with moveTo, which can stall AE.
- Then it applies parenting, effects, masks, transforms, eases, mattes and environment-light wiring.
build.py spec.json --new --only "A|B" --stills "Comp:t1,t2" --save output.aep
- --new closes the current project without saving first (CloseOptions.DO_NOT_SAVE_CHANGES). Otherwise newProject() opens a Save As dialog and hangs.
Stills: stills.py "Comp" t1,t2 prefix.
- saveFrameToPng is asynchronous (poll until the file exists) and writes 16-bit PNGs (divide by 257 before 8-bit viewing).
Targeted motion renders: render.py "Comp" start end out.mp4 [--half] [--hq], or aerender with -s/-e.
Full renders: aerender_job.py "Comp" out.mp4 [--half] [--hq].
- It saves a job copy and runs aerender -project job.aep -rqindex 1 -sound ON in a separate process.
- It is faster than the in-app queue, and a crash cannot take down the working instance.
Contact sheets: contact.py (frames from a video) and sheet.py (stills, keeps aspect). Always shrink images before viewing them.

A5. ExtendScript rules (ES3)

No JSON and no Array.indexOf: use the polyfill or loops. Read JSON with eval('('+text+')').
Never use chained ternaries (a?x:b?y:z evaluated wrongly). Use if/else.
Address properties by matchName. Display-name lookups have a 39-byte limit and are localized.
A camera is not threeDLayer: test matchName==='ADBE Camera Layer'.
Normalize value dimensions: pass scalars to separated dimensions and 3-element arrays to 3D properties.
shutterPhase must be an integer.
Set applyFill=true before setting a text fill color.
Create a fresh TextDocument per layer. Call resetCharStyle()/resetParagraphStyle() before styling.
A "property or parent is hidden" error means the property does not apply there. Example: the Y Rotation of an environment light cannot be set; animate its source map instead.
Shape Gradient Fill colors cannot be scripted. Use a Gradient Ramp effect or layered light groups.

A6. Coexisting with other agents

Other agents may quit AE "by name", which also hits your instance. Save often, and keep ensure_ae.py ready.
Pressing Escape on a quit-triggered "Save changes?" dialog quits AE.
Computer-use and accessibility tools may only see other instances' windows. Diagnose your own windows with a Quartz window list filtered by PID plus screencapture -l <windowId>. Dismiss them via System Events on your PID (key code 36 = Return, 53 = Escape).
Disclose any accidental interference with another AE instance.

Part B – Rules that always apply

Apply these rules in both modes to keep the motion smooth and the project editable.

B1. Keyframes: as few as possible

Use as few keyframes as possible to get smooth motion. Ten keys with curves beat a thousand flat keys.
One gesture needs 2–4 keys: start, end, and a real hold or a real extreme (peak, valley, phase change).
Cap each property at about 7–12 keys. More keys usually means the motion is not designed.
Never bake motion as per-frame (or 2-per-frame) linear keys. An editor cannot edit it, and it looks mechanical.
When motion comes from measurement or legacy data, fit it (see B3). Never paste samples.

B2. Curves: a smooth arc in the speed graph

Open the speed graph of every animated property.
- A smooth bell or arc means smooth motion.
- An angular, stair-step graph (every key easy-eased to zero) means the motion stutters.
- A spike means a jerk, unless it is an intentional accent.
Interior keys of one continuous gesture must not stop.
- Use continuous Bézier keys.
- Set the interior speed to the harmonic mean of the neighbouring slopes, 2ab/(a+b) when both have the same sign, else 0, at an influence of about 33.3.
- Never apply a global Easy Ease to a continuous gesture: it creates the stair-steps.
Ease vocabulary (out influence of the previous key / in influence of this key):

Name Influence
ease 33/33
smooth 70/70
inout 82/82
out 12/88
expo 6/94
snap 3/97
in 88/12
soft 45/75

A custom ease is {'o':[speed,inf],'i':[speed,inf]}. A soft pull-back, for example: {'o':[0,55],'i':[0,92]}.
Spatial tangents default to zero, which avoids path overshoot. Use arcs only on purpose.
A move that is too short with a harsh expo start reads as a jerk. Lengthen it (0.5 → 0.8 s) and soften the ease rather than adding keys.
Overlap sub-moves into one gesture. A fold then a flip then a push, done separately, gives stop-and-go motion. Start the next move before the previous one ends.

B3. Fitting curves from data

Recreate mode, or when converting any dense data:

Sample the target motion densely (50–200 Hz) with valueAtTime or from measurement.
Fix knots at the start and end, at exact holds (zero speed), and at significant extrema (zero slope on that axis).
Solve speeds and influences by least squares against the samples: speeds sign-constrained, influences bounded to 0.04–0.94.
Add a knot only where the error exceeds tolerance:

Property Tolerance
Position 2–3 px (camera 3 px)
Scale 0.4–0.65
Opacity 0.5–2.5
Blur ~1
Rotation 0.4
For vector properties, merge knot times across axes by splitting the Bézier (de Casteljau). Assert that the incoming speed equals the outgoing speed at every interior key.
Keep as-is, with a written reason: expressions, time remap, typing cadence, deliberate hold switches, one-frame visibility flips.

B4. One 3D camera per scene

Every scene has one CAMERA • scene (one-node, NO_AUTO_ORIENT, separated X/Y/Z). The camera carries the framing, pans, dollies and zooms.
Don't animate Position/Scale on every element to fake a camera move.
To derive a camera from recorded UI motion (main layer position P, scale s, comp centre C, zoom Z0):
- camera XY = C + (C − P)/s
- camera Z = −Z0/s
Then re-express everything that moves on its own in local terms.
The camera tells the story: arrival → action → acceleration → readable settle, and macro detail → pull-back reveal.
Local animation stays local: a cursor path, a click press, a scroll, a card flip. Parent click pulses inside the component, so they follow it under perspective.
Headlines live on a stable 2D plane above the 3D world, so camera pushes never clip them. Verify with a projected text-bounds check.

B5. Motion blur, sharpness and depth

Comp motion blur is on (shutter 135–180°, 12–16 samples).
- Lower the shutter to 45–90° on very fast pull-backs, or UI smears.
- Turn motion blur off on layers where it doubles text.
Keep large zooms of UI sharp: a 2–4× supersampled render-plane precomp that holds the editable vector UI, and no collapse on camera scenes.
Advanced 3D renderer: keep ≥ 4 units between parallel planes, or they z-fight and show seams.
A null's opacity does not affect its children. Propagate opacity to all descendants.
Blurred glows must have Repeat Edge Pixels OFF, otherwise they show rectangular bounds. Full-frame radial Ramps make the best light fields.

B6. Transitions: continuity, not effects

A transition should be motivated:
- Match cut: the last frame of A equals the first frame of B. Measure the pose in the render.
- Morph: one shape animates size, roundness, colour and position into the next element.
- Object handoff: an element is extracted and becomes the next scene's hero.
- Camera dive into a dark element, so the next scene emerges from black.
- Light or dark disc reveal behind the product via a track matte.
Forbidden:
- full-frame white or grey flashes;
- crossfades between dark and light scenes, which produce mid-grey frames;
- the same wipe on every cut;
- grey background "sweep" stripes.
Put flashes where they physically belong: on a display, with a coloured bloom behind the object.
Use at most 2–3 full-frame occlusion wipes per film.

B7. Native only, editable always

Asset downloads: Download any assets needed for the task without asking the user first, including logos, icons, fonts, 3D models, textures, images, video references, music and sound effects. Prefer official or reliable sources, retain required licence attribution, and apply the native-project rules below when using the assets in AE.
Native means text, shapes, masks, effects, precomps, cameras, lights and native 3D Model layers (GLB/OBJ). Audio may be imported.
- Never import screenshots, reference crops, pre-renders, webcam loops or raster substitutes for native layers.
- Audit every footage item before claiming "native".
Editable means live text, sliders for controls, clear layer names and reusable component precomps that propagate changes wherever they are used.
Keep text centred after edits with an anchor-point expression from sourceRectAtTime.

B8. Typography

Live text only, with the real brand fonts. Check with getFontsByPostScriptName, and install static instances under a unique family name when needed.
Headlines are short, heavy, sentence case, with a full stop. Tracking −20 to −40.
Reveal per character or word: opacity 0, blur 20–24, y +14–26, ease-out over 0.45–0.55 s. The exit mirrors the entrance: 0.25–0.35 s, blurring upward.
Measure widths against the real TTF (PIL at 4× supersampling) so underlines, pills and layouts fit exactly.
Keep text inside the platform's safe zone. For an Instagram reel, key text sits above y ≈ 1520–1560 and out of the right-hand icon column.

B9. Sound

SFX sources: Download any sound effects needed for the task without asking the user first, including from Pixabay or other suitable sound libraries. Choose effects that fit the action and timing, and retain any required licence attribution.
If the brief says the edit follows the music, every visual event must land on a beat or half-beat.
SFX registry: each scene calls sfx(t, kind, gain) while building, so sound is born in sync. Use downloaded recordings, synthesized effects, or a combination in the kit:
- tick, pop, swish, whoosh, tink, shimmer;
- fold, hinge, boom, draw, chime, shutter, charge;
- riser, reverse.
Every micro-event gets a sound: a title in, a card landing, a bubble, a focus, a counter tally.
AE sums audio layers at 0 dB and will clip. Pre-master outside AE:
- music + SFX through a lookahead limiter at −1 dBFS, about −13 LUFS;
- the MASTER mix as the active layer;
- the stems kept as muted layers.

Part C – RECREATE process (1:1 to a reference)

Mindset. You are a forensic motion designer. The reference is the truth. Never guess what happens; measure it. Timing is fixed first, then layout, then motion, then material and colour. "1:1" is claimed only with side-by-side evidence, and every remaining deviation is listed honestly.

C1. Lock the goal and the rules

Write the goal: "Native AE rebuild of <reference>: same cut points, layout, motion curves and look; native layers only; reference audio allowed as audio; editable structure."
Apply the brief's asset constraints. Under a native-only brief, rebuild photographic UI content as native artwork and disclose any resulting visual deviation.
Set the delivery spec from the reference: resolution, fps, duration, frame count.

C2. Ingest the reference

Run ffprobe for resolution, fps, duration and frame count. Build a frame-index map (t = frame/fps) and always work in frames.
Make contact sheets at fixed timestamps. Then step frame by frame through every cut and write the exact cut frames down.
Extract the audio and keep it as the soundtrack. Detect onsets so you know where the accents sit.
OCR the text (a Swift Vision script) to get exact wording. Identify the fonts.

Think: "What happens between the key poses? Which beats would a quick look miss?" Check interstitials, repeated page swaps, progressive reveals and the formation of logos.

C3. Decompose the reference into shots

For each scene, identify:

the exact start and end frames;
every element, with its type (text, card, cursor, background, light);
every event with its frame (enter, type, click, scroll, exit);
camera behaviour (pan, dolly, zoom, parallax);
transition in and out;
the look: colours sampled from pixels, blur, glow, shadows.

Use this breakdown to guide every build step.

C4. Measure, never eyeball

Use OpenCV to produce numbers only; reference pixels never enter the project.

Cards and windows: threshold, contours or Canny edges give position, size and scale per frame.
Cursor: colour mask plus moments give its path; covariance gives its orientation and press-scale.
Buttons and circles: Hough circles.
Gallery items: SIFT template features per card.
Scroll: Lucas-Kanade optical flow.
Background light field: fit it as NNLS over a Gaussian basis (for example 17×11) with text masked out, then rebuild it as named native ellipse and ramp layers.
Colours: pixel samples away from text. Compare only against PNG stills, never against frames extracted from JPEG or MP4.

C5. Build the skeleton, timing first

Create the master and one comp per scene, with exact durations placed on the exact cut frames.
Add rough native elements in the right positions, and build the whole film roughly before polishing any single scene.
Checkpoint: a contact sheet of the rough build against the reference at identical frames. Cut points and element presence must match before you go on.

C6. Rebuild the motion

Turn the measured samples into sparse fitted curves (B3).
Derive the scene camera from the main UI motion (B4). Keep the cursor, clicks and scroll local.
Match character, not just the endpoints:
- scale curves on card entrances;
- menus that collapse toward the chosen control;
- scroll that keeps accelerating into the exit;
- the cursor staying locked to its button during zooms;
- sharpness returning gradually, never a frame early.

C7. Rebuild the look

Materials: glass type (fill + stroke behind + Bevel Alpha + light layer), light fields, glows made of nested native shapes (never blurred rectangles), directional blur streaks (ADBE Motion Blur) on pull-backs.
Use sampled palette values and the right fonts.

C8. The comparison loop (repeat until it holds)

Stills at identical frames, reference next to native, including in-between frames where jerks hide.
Pixel metrics on tracked elements, for example the mean edge error of a card. Exclude confusers such as the cursor outline. Say that a metric covers one element, not the whole film.
Targeted renders of only the changed spans (-s/-e). Never re-render the whole film to check one fix.
A side-by-side comparison video (ffmpeg hstack, reference | native, with audio) for the whole-flow check.
Work in priority order: timing → layout → motion curves → colour and material → micro-detail.

Think: "At this exact frame, where is every edge in the reference, and where is it in mine? If they differ, is it timing, position, curve shape or look?"

C9. Make it editable and finish

Speed-graph audit (B2), key counts, native audit (footage = audio only, no substitute fonts, no expression errors).
Keep text and controls editable, and use clear layer names.
Then continue with Part E.
Report: what matches (with evidence), what still deviates (list), and what was never proven.

Part D – CREATE process (original film)

Mindset. You are the creative director and the motion designer, and the bar is a real award jury. Invent an idea, not a list of animated features. Every scene must earn its place, every transition must be motivated, every detail must be true to the brand or product. Never call it award level after one pass: set a goal, then review and iterate until the result meets the benchmark references.

D1. Lock the brief

Establish from the brief and available context:

platform and aspect (an Instagram reel is 1080×1920 with a safe zone);
fps (60 for smooth social motion, 25/30 for web);
duration (at least the benchmark);
music and brand;
truth constraints: does the product or app really exist? If not, frame it as a concept or fan film.

Write a goal with a hard minimum bar, for example "≥ benchmark length and complexity, native, editable, continuous transitions, drop-synced".

D2. Deep research

Use a research subagent to establish brand and product facts from reliable sources.

Brand:
- exact colours from live CSS computed styles (Playwright with the system Chrome channel; dismiss the consent banner);
- fonts, the official logo SVG paths;
- tone of voice, slogans, real products and prices, real services.
Product:
- official facts from the maker's page and newsroom (sizes, materials, finishes, cameras, battery, dates);
- never invent specs. Verify current product facts against official sources.
Check whether the product or app exists. If it doesn't, the film is a concept: no store, price or date claims.
Use the research to select the palette, fonts, accurate UI strings and viable story angles.

D3. Study the inspiration and benchmarks

Make contact sheets of every reference and benchmark. For each one, write down one transferable principle, for example "airy UI depth", "scale changes", "object becomes UI", "a new mechanism per feature". Never write down a layout to copy.
Analyse the benchmark audio (onset density, brightness) to calibrate sound-design density.
Think: "What makes this benchmark feel expensive? Is it restraint, continuity, light, rhythm or detail?"

D4. The concept and the motif

Pick one central visual motif that threads through every scene and pays off at the end. It can evolve from a simple shape into a transition, interaction or final brand mark.
Write the title line and tagline in the brand's voice.
Plan an arc: hook → tension → drop or reveal → feature beats → emotional peak → quiet signature ending.
Give each scene a different staging mechanism: macro, device reveal, live typing, carousel, product stage, kinetic type, spatial checkout, 3D gallery flight, morph, signature hold. Repeating a layout or trick is the #1 cheap signal.

D5. Music and the beat grid

With a given track:
1. Find the BPM with kick-envelope autocorrelation (low-pass under 150 Hz). Check the result against the audible pulse; generic onset flux can mistake subdivisions for the beat.
2. Find the drop from sustained low-band energy jumps.
3. Phase-fit the grid (check on-beat against half-beat strength).
4. Cut the song with ffmpeg -ss … -t … afade so the drop lands exactly on a chosen frame. Verify the energy around it.
5. Define beat(k), with one scene per phrase (8 beats). The hero action lands on the drop, and the ending sits on the breakdown.
Without a track: synthesize an original score (numpy: plucks or Karplus-Strong, bass, drums, pads) on a fixed BPM grid, and say it is a placeholder.

D6. Story and beat sheet

Format, BPM grid, motif, palette, typography, craft rules.
Plan each scene's beats and seconds, content, transition in and out, and key SFX.
Plan every transition here as continuity: match cut, morph, handoff, dive, light reveal. Never "flash to the next scene".

D7. Moodboard and style

Build the moodboard with PIL or SVG: swatches, type specimens, logo, inspiration frames, each captioned with the principle taken.
Palette = brand colours plus a small, explicitly labelled film extension (for example warm paper and stage black). No random neon, no generic blue SaaS glow.
Keep W, H, FPS, BPM, beat(), colours, font PostScript names and font files in one shared configuration.

D8. Acquire the real assets

Product 3D model: always a real, ready-made model of the exact product. Never a model of a different product, never a hand-built approximation.
1. Search Sketchfab, CGTrader, MakerWorld and similar sites.
2. Check the licence (CC BY requires a credit).
3. Obtain the selected model and retain its source and licence information. Never log in or create accounts.
4. Inspect it headless: blender -b file.blend --disable-autoexec --python inspect.py.
5. Dump the evaluated meshes into your rig space.
6. Split it into rigid parts for articulation (for example the two halves of a foldable).
7. Write GLBs with PBR finishes and embedded textures for photo-real details (lenses).
8. Import into AE as 3D Model layers. AE maps glTF (x,y,z) to (x,−y,−z)·512 px; reset the anchor to 0,0,0; use Advanced 3D.
Light the model with an environment light whose source is a hidden precomp of blurred softboxes (dark env for dark scenes, light env for light ones, intensity about 80). Drift the softboxes so the reflections move. All other 3D layers stay unlit.
Screens are precomps pinned exactly onto the model's display area (measured size, corner radius, 4–5 px z-offset) and stay continuous across folds.
Logos: the official SVG converted into native shape paths (even-odd fill for holes).
Fonts: verified and installed; bundle them only if the licence allows.

D9. Build the foundations

Drive mechanical articulation, deformation and numeric displays through reusable null and slider rigs. Keep controls consistent across scenes.
Film-time screen comps (home screen, apps, lock screen, viewfinder) that every scene references with startTime = −sceneStart.
Environment maps, grain, and background systems.
The smoke test: build one test comp that exercises every feature (camera, 3D model, env light, masks, mattes, text animators, trim) and check the stills.

D10. Build scene by scene

For each scene:

Build that scene only (--only).
Take stills at every phase time and view them as a contact sheet.
Fix it.
Render a short motion clip if the motion matters.

Build the transitions with the scenes: make scene B's first frame match scene A's last frame.

D11. Full-pass review, with the award jury's eyes

Render at half resolution with audio. Then look at:

an overview sheet;
a cut sheet around every boundary (−0.3, −0.12, −0.03, +0.02, +0.12, +0.3 s);
fine transition strips every 5 frames.

Review the film against these questions:

Is there one idea, and does the motif pay off?
Does any scene repeat the framing, transition or camera of another?
Is every cut continuous? Are there any grey, flash or empty frames?
Does anything touch the frame edge, overlap a title or leave the safe zone?
Is every event on the beat? Does the drop hit?
Is there light moving on materials? Contact shadows? Rim light?
Is every UI state semantically right (search results, prices, facts)?
Do the speed graphs show smooth arcs, with no stop-and-go gestures?
Is there sound on every micro-event?
Compared with the benchmark, what is still weaker? Write it down honestly.

D12. Polish loops (repeat)

Replace every flash or crossfade with continuity (B6).
Merge stop-and-go moves into one gesture.
Add detail: moving reflections, glints, contact shadows, depth-of-field emphasis, micro-interactions.
Remove cheap elements: background stripes, hard glow edges, generic glows, stray effects that recolour strokes.
Re-check the motion with the projected speed audit (motion_sample.jsx + motion_check.py).
Add missing micro-SFX. Space counter ticks along the easing curve.
Each fix: targeted stills or clip → confirm → next. Re-render the full pass only after a batch of fixes.

D13. Master the audio

Mix music and SFX with the limiter (−1 dBFS). Check: 0 clipped samples, loudness, audible drop. Keep the stems muted in the project.

Then continue with Part E.

Part E – Finish (both modes)

E1. Final QA

Restart AE after heavy iteration, since repeated rebuilds cause crashes. Do a clean build and save.
Run the final render from the final saved AEP via aerender. Never stitch segments from different versions.
Verify the render:
- ffprobe: resolution, fps, frame count, duration, bitrate, audio stream;
- ffmpeg -v error -i out.mp4 -f null - decodes fully;
- an automated scan finds 0 uniform grey frames and no black gaps;
- audio peak ≤ −1 dBFS, 0 clipped samples;
- full-resolution detail crops look sharp;
- facts and strings are re-checked against the sources.
Project audit:
- footage is audio (and GLB) only;
- no missing footage, no substitute fonts, no expression errors;
- key counts are within the caps;
- the render queue is empty;
- unreachable comps are pruned.

E2. Package the deliverables

Deliver the final AEP and required audio, models, textures and redistributable fonts. Retain licence attribution where required.
Export the MP4 at the platform specification (H.264 around 40 Mbps, AAC 48 kHz, unless the brief specifies otherwise).
Build any requested archives from an explicit allowlist. Exclude autosaves and logs; include source scripts and analysis assets when required by the deliverable.
Validate archives with testzip() and compute SHA-256 hashes for the AEP and video.
Test relocation by opening a copy with the original asset locations unavailable and checking that all required media resolves.

E3. Communicate the result

Give progress updates during long work. At completion, provide the deliverable locations, specifications, relevant credits and limitations.
Honesty:
- never claim "native", "1:1" or "award level" without evidence;
- layer and key counts describe breadth, not quality;
- list the deviations and what was not proven;
- disclose downloads, installs (and how to remove them), crashes, and any interference with other agents;

Appendix – Rendering and environment pitfalls

Symptom	Cause	Fix
DoScript hangs, AE at 0% CPU	A modal dialog (Crash Repair, Save As, missing font, low disk, alert)	Suppress dialogs; close the project without saving before `newProject`; create folders before saving; find your dialogs by PID and dismiss them
Your instance quits	Another agent quit by name, or Escape on a quit dialog	Target by PID, save often, `ensure_ae.py`
"Thread stack size exceeded" crash	Many `--new` rebuilds in one session	Restart AE regularly; render with aerender
Stills never appear, or show "rainbow" bands	Asynchronous save or a blocking dialog; 16-bit PNG	Poll for the file; divide by 257
Seams, or planes showing through	Advanced 3D z-fighting	Keep ≥ 4 units apart; separate z in overlap bands
Children ignore a fade	Null opacity is not inherited	Propagate opacity to descendants
Rectangular glow edges	Blur "Repeat Edge Pixels" on	Turn it off; use full-frame Ramps
Doubled text, smeared zooms	Shutter motion blur; continuous rasterization	Turn MB off per layer; supersampled render plane; shutter 45–90°
Text clipped in camera pushes	Titles on the 3D plane	2D title plane + rank ordering; projected bounds check
Scale from the wrong centre	Geometry offset inside the group	Geometry at 0,0; move the layer
Click pulse drifts off its button	Pulse lives in scene space	Parent it inside the component
"Unknown shape item"	A nested group not wrapped	`{'group': g}`
Wrong colour judgment	Half-res H.264 decode	Judge only on PNG stills or the Full HD render
Env light rotation error	The property is hidden	Animate the softboxes in the env map
Clipping audio	AE sums layers at 0 dB	Pre-master with a limiter; mute the stems
ZIP includes unnecessary files	AE Auto-Save and Logs folders	Explicit allowlist
A patch silently did nothing	Heredoc or f-string escaping	Assert every replace (`assert a in s`)
Tool gaps on macOS	No `timeout`; ffmpeg has no `drawtext`	Until-loops; OpenCV or PIL labels

Name	Influence
ease	33/33
smooth	70/70
inout	82/82
out	12/88
expo	6/94
snap	3/97
in	88/12
soft	45/75

Property	Tolerance
Position	2–3 px (camera 3 px)
Scale	0.4–0.65
Opacity	0.5–2.5
Blur	~1
Rotation	0.4

Ask in your favorite AI

Documentation