Computers turned into a
Digital Human.

DaemonLabs  /  Case  /  Pro Video Editing (DaVinci Resolve + iMovie)

Get in touch
Scroll Down
0:00 / 0:00
Current Focus
Procedures
are still manual
and painfully repetitive.

Editors still spend hours repeating deterministic actions: importing rushes, syncing audio, trimming dead air, placing markers, organizing bins, and exports. We are focusing on automating those exact repeatable steps first.

Workflow Strategy
Procedure packs for
DaVinci Resolve
and iMovie.

Using native macOS-first accessibility hooks, we map timeline and inspector actions into deterministic procedures. Today the focus is professional video editing flows in DaVinci Resolve and iMovie, not generic all-purpose desktop automation.

02 — Architecture

Three core layers. Zero hallucination.

01
UI Targeting Engine
C++ · ControlFromPoint

In Resolve and iMovie, timeline targets move constantly. We query the OS accessibility tree at click time so the system can reliably target transport controls, inspector toggles, timeline clips, and export actions in milliseconds.

01
02
Procedural Memory
Workflow Compiler

Record once: import footage, sync audio, split clips, add markers, normalize audio, and export. Our compiler stores those as JSON procedures so recurring edit jobs replay deterministically without prompt guessing.

02
03
Self-Healing UI
pplx-embed · INT8

UI labels vary between app versions and layouts. Lightweight local embeddings match semantic intent (for example, Deliver/Export or Inspector/Settings), helping procedures survive small naming and placement changes.

03
03 — Orchestration Layer

One Orchestrator. A Swarm of Specialists.

Instead of claiming every workflow, we are shipping deep vertical coverage for video editing first. A planning model routes tasks to specialized sub-agents that execute deterministic DaVinci Resolve and iMovie procedures.

01
Timeline Procedure Driver
Executes timeline operations such as clip selection, split/trims, ripple deletes, marker placement, and playhead-aware jumps with strict UI targets.
02
Media Prep Driver
Handles media import, bin organization, and file preparation before edits begin, reducing repetitive setup work across recurring projects.
03
Procedure Guardrail
Validates every action schema and blocks invalid tool calls, so long edit procedures fail safely instead of drifting into bad UI actions.
04
Cut Memory Agent
Retrieves stored editing procedures (Resolve/iMovie specific) from local memory and maps them to the current project context.
Coordinator
Orchestrator
Live Task Trace
→ waiting for task
0ms
UI Targeting Latency
0px
Target Resolution Radius
10
Hallucination Loops
0%
Deterministic Replay
05 — Feature breakdown
01 / Perception
UI Targeting
Engine
Using macOS-first accessibility targeting, we pierce through editing app UI layers the exact millisecond a click happens. This keeps timeline actions stable while panes, tracks, and panels shift.
auto.ControlFromPoint(x, y)
if not target:
  snap_to_nearest(60px)
OS Layer
Sub-1ms
02 / Resilience
Precision Target
Resolution
Editors click tiny timeline and inspector targets constantly. Our Euclidean distance resolver snaps imperfect clicks to the nearest valid semantic target to keep procedures reliable.
dist = math.hypot(cx-x, cy-y)
if dist < 60:
  target = closest_el.Name
Math Layer
Active
03 / Orchestration
Multi-Model
Orchestration
The orchestration layer routes each editing step to the right specialist: timeline action, media prep, validation, or export. Sub-agents run on local context to keep latency and token use low.
plan = Orchestration.plan(goal)
for task in plan:
  ui_driver.run(task)
Routing
Orchestrating
04 / Robustness
Validation
Guardrail
Small models stubbornly repeat bad tool calls. Our middleware intercepts invalid JSON actions and physically forces the correct schema into the error prompt to guarantee recovery.
if act not in tools:
  return "CRITICAL ERROR: Use exactly {'action': 'click'}"
Middleware
Shielded
05 / Memory
Workflow
Compiler
Replaces stateless guessing with procedural memory. We store repeatable Resolve/iMovie cut procedures as deterministic JSON flows and replay them for recurring edit requests.
{
 "action": "click",
 "semantic_target": "Send"
}
Memory
Compiled
06 — Under the Hood

Drives the macOS. Like a human.

Watch the Multi-Model Orchestration layer in action. The coordinator decides what to do, the Terminal Driver finds the files natively, and the GUI Driver executes the clicks. All protected by semantic embeddings.

› eh run "Email Q3 report to Boss"
✔ Coordinator routing to Terminal Driver...
✔ [Terminal] File found: C:/docs/Q3.pdf 4ms
✔ Coordinator routing to GUI Driver...
› GUI.click(semantic_target="Compose")
✔ Target resolution successful (dist: 12px)
› GUI.click(semantic_target="Send")
⚠ UI changed: 'Send' not found. Running pplx-embed...
✔ Semantic match found: 'Submit' (similarity 0.94)
✔ Task complete. (Total tokens saved: 45,200)
›

Your machine. Your rules.

We are currently focused on one vertical: professional video editing automation. If your team uses DaVinci Resolve or iMovie and wants repeatable procedures automated end-to-end, get in touch with DaemonLabs.

mayank@echoed.in copied