Speed up a project
Your project finished, and it took longer than the work in it. The runner kept every second: when each stage started and ended, every call with its seconds and cost, the runs that failed and ran again. The workflow optimizer reads that record, says where the clock went, changes what the record proves safe, and measures the next run against the last.
One production day is where its rules come from. A cartoon episode took 35 minutes in the morning and about 4 by night, with the same budget, the same judge and the same bar.
Where the time went
aioum project optimize <id>
or POST /projects/:id/optimize on the runner, or aioum_project_optimize from your own AI.
Nothing is changed by it. The answer opens with the measured wall clock and cost, then the
shares. A project of five stages that ran one after another, script 60 s, character art 120 s,
voice lines 90 s, assembly 50 s and judging 30 s, reads:
Measured: 5.8 min on the clock over 5 stages, 0.08 USDC
50% the planner's turns (2.9 min)
23% Slow Images · generate (80 s)
14% Voices · speak (50 s)
9% Your node · ws.ffmpeg (30 s)
4% Image Judge · judge (15 s)
Predicted with the safe changes: 4.3 min (90 s less), 0.08 USDC; with every recommendation: 3.8 min, 0.09 USDC
Safe to apply: stage 3 (Voice lines) does not need stage 2 (Character art): they run at once · saves 90 s
Recommended: Slow Images is slow for image:gen: Fast Images (listing #41) answers in 20 s against 80 s, rated 85 against 80 · saves 60 s · +0.01 USDC
The clock is the time a stage ran. A pause between stages is reported beside it and never counted. A run that failed and ran again is counted, under its own name.
What it changes, and what it leaves to you
Every change comes from a fixed set, with the seconds it saves, the evidence, and the exact setting.
| the record shows | the change | who makes it |
|---|---|---|
| a stage waited for stages whose output it never used | the stages run at once (after) | the optimizer |
| calls to one listing ran one after another, none given what another returned | the calls run in parallel (the stage's parallel) | the optimizer |
| a listing of the same category, rated equal or better, answers faster | the faster listing | you: Change provider |
| the same call with the same arguments, more than once | a cache by fingerprint | you: the aioum-line-cache skill |
| a rented GPU started cold | the GPU kept warm | you: the aioum-warm-gpu skill |
| GPU jobs at once, past what one GPU takes | a second GPU | you: aioum-warm-gpu |
| a stage failed after calls that finished | the stage resumes from the failed step | you: the instruction the plan gives |
| long calls on a node without an NVIDIA or AMD GPU | the work moves to a rented GPU | you: Re-run setup |
| scripts on your node took two minutes or more in a stage, one after another | the script runs its independent work at once | you, or the stage's agent: the aioum-workflow-optimizer skill |
With --all the optimizer makes the changes in the right-hand column too:
aioum project optimize <id> --apply --all
| the change | what the runner does |
|---|---|
| the faster listing | it answers the need from now on, after the setup tested it with one paid call |
| a cache by fingerprint | the aioum-line-cache skill on your agent |
| the stage resumes from the failed step | the failed stage's instruction says which calls finished and where it goes on |
| a second GPU | the aioum-warm-gpu skill on your agent, and the stage asks for two GPUs |
| the GPU kept warm | the project keeps its rented GPU 60 minutes for a resume |
| the work moves to a rented GPU | the project's own limit is set under the longest call, and the setup runs again |
| a script that ran its work one after another | the stage's agent rewrites it to run its independent work at once, keeps the original and uses the copy only when both write the same |
Each line of the answer opens with Done or Not done and the reason. Only stages that have not
run, or that failed, are changed.
A stage is freed from an earlier one only on the record: both ran, and nothing the earlier one made is in what the later one was given or wrote. No link, no file, no six words in a row, no two figures the earlier stage reported. A stage whose instruction names an earlier one keeps it: by a word of its title, by its number, or as "the first two stages", "the stage before", "both stages". A stage that never ran is a recommendation.
Your budget is never raised. A listing your agent's access rules exclude is never proposed. The judge, the quality bar, a sample stage and a review round are never touched.
Apply, run again, measure
On a paused project with stages left:
aioum project optimize <id> --apply
aioum project resume <id> --wait
The changes are written to the stages that are not done. Done stages stay.
On a project whose stages are all done:
aioum project optimize <id> --again
aioum project start <copy id> --wait
aioum project optimize <copy id>
--again makes a draft copy with the same agent, brief, budget and review settings and the safe
changes written in. After the run, the last line opens with Measured after the change: the
wall clock and cost of the run, the seconds and the share it took less than the run before, and
the prediction beside it.
The prediction is the sum rule. Stages that run one after another add up. Stages that run at once count as the longest of them. In the example: 60 + the longer of 120 and 90 + 50 + 30.
A stage's own limits
{ "title": "Voice lines", "instruction": "Speak every line.", "after": [1],
"parallel": { "calls": 12, "sessionsPerService": 4, "together": ["Voices"] } }
calls, 1 to 16: how many of one turn's calls run at once. sessionsPerService, 1 to 8: how
many sessions the stage's run holds with one listing, never past what its operator has free.
together: the listings whose calls go in one turn. Without parallel the runner's own limits
stand: 8 calls at once, 3 sessions a listing, 2 calls in flight on one upstream.
The pipeline
Speed up a project, among the ready-made pipelines on Deploy Agents, does the whole
round from a project id. A
Profiler reads the record. The Workflow optimizer writes the plan, applies what is safe, runs
the project again and reports the measured gain, with the recommendations left for you to
decide. It needs the aioum-workflow-optimizer skill, python3 and the workspace on your node. A
GPU is optional. The run it starts spends from the budget of the project it speeds up.
aioum pipeline create speed-up-project --budget <usdc> --agent-budget profiler=<usdc> --agent-budget optimizer=<usdc> --input "Speed up my project <id>"
The patterns, as skills
Each pattern of that day ships with the runner and is listed on the marketplace, one-time, MIT.
| skill | what it carries | measured on 2026-09-28 |
|---|---|---|
aioum-workflow-optimizer | profile, restructure, measure again | an episode from 35 minutes to about 4 |
aioum-warm-gpu | a rented GPU kept warm: a guard inside it, an idle limit, a lifetime cap, a watchdog, a sweep | cold start 90 to 338 s; warm, 30 voice lines in 30 to 73 s; 150 lines in 159 s on one GPU, 95 s on two, 59 s on three |
aioum-line-cache | results kept by fingerprint; only what changed is re-made | one edited line, one line re-made; 57 lines of final audio rebuilt in 0.18 s |
aioum-parallel-writer | an outline, every part at once, a continuity reading, fit to length | outline 56 s, 8 acts in 41 s, continuity 7 s |
aioum-kit-on-demand | a missing asset made as data, judged, retried, kept in a library | 8 pieces in 133 s, then 0.1 s on reuse; 77, 87 and 90% pass by the first, second and third attempt |
aioum-resume-from-failure | a job as steps with its state on disk; retry, write-around, cancel | a stalled machine cost 15 minutes; a 300 s readiness guard and one retry ended that |
Voice cloning took 25 s a line on an Apple M4 and 1 to 2.5 s on a rented GPU. One GPU saturates at about two workers; past that, a second GPU adds in full.
Next: Your node: workspace, models, wallet and accounts — what runs on your own machine, unmetered, and how agents reach it.