Autoprompt skill: fewer failures, more tokens

What Autoprompt is

The Autoprompt skill for coding agents is a multi-agent orchestration layer that you start with one slash command. You give it a goal. It plans, builds, tests, reviews and repairs, and it stops to ask you only when a decision needs a human. The project reports 73 of 89 tasks solved on Terminal-Bench 2.1 where the same setup without the skill solved 60.

The same project states the price of that result: about three times the execution time and about twice the tokens. Read the two facts together, because they come from one design. Autoprompt buys accuracy with extra model calls, and extra model calls cost minutes on your machine and money at your model provider.

What the Terminal-Bench 2.1 numbers say

Terminal-Bench 2.1 is a set of 89 terminal tasks covering software engineering, machine learning, security and data science. Each task runs in its own container and is graded by tests, so a task passes or it does not. There is no partial credit, which makes the counts easy to read.

[
  {
    "label": "OpenCode alone",
    "tasks_solved": 60,
    "failures": 29,
    "score_percent": 67.42
  },
  {
    "label": "OpenCode with Autoprompt",
    "tasks_solved": 73,
    "failures": 16,
    "score_percent": 82.02
  }
]

The harness solved 60 of 89 tasks on its own and 73 with Autoprompt loaded. Failures fell from 29 tasks to 16. That drop is the 45 percent figure the project leads with. The pass rate moved from 67.42 percent to 82.02 percent, which sounds like a smaller claim, and both describe the same 13 tasks.

Read the numbers with their limits attached. They come from the project's own documentation, on OpenCode 1.18.7, on one benchmark, in one run. We have not reproduced them, so treat every figure in this section as the project's rather than ours. A single harness result does not transfer automatically to a different agent, a different model or your repository.

The cost side is weaker evidence than the accuracy side, and the project says so. The documentation states that timing and token logs were not retained, so the 3x time and 2x token figures are planning estimates drawn from user reports, not measurements from the benchmark run. Plan your budget with them. Do not quote them as measured.

Why it is an orchestration layer, not a prompt template

A prompt template is text. It changes the wording of one request to one model, and it costs you the tokens the text occupies. If the format is new to you, start with what an agent skill actually is, because Autoprompt uses that packaging and then goes well past it.

Installing Autoprompt registers a command inside the coding agent you pick. Calling that command splits your goal into phases: planning, build, review, tests, sign off and sweep. Work is handed to subagents that run in their own context, in lanes that can run at the same time.

The layers are kept apart on purpose. One layer coordinates, one manages, one executes and one judges. The judge is a separate model call with its own context, so it does not inherit the builder's belief that the work is finished. That separation is where the extra solves come from. An agent that plans, writes and approves its own work will approve its own mistakes, because the context that produced the bug also produced the confidence.

The cost has the same root. Every phase is another model call over the same code, and several lanes read the same files again. You are paying for a second opinion, and second opinions are not free.

Modes, and how to cap the fan out

Three controls ship with the skill, passed in the same line as the goal.

• mode=tokensaver caps the number of subagents at six.
• mode=wide opens every lane that is ready.
• mode=custom max_subs=N sets your own ceiling.
• agents= routes work to specific models on the platforms that support routing.

On a rented box the ceiling is the setting that matters, because each open lane is work your machine performs. Start low and raise it once you have watched a run.

What 3x wall clock time means on a machine you rent

A run that used to finish in twenty minutes now takes an hour. On a laptop that is a nuisance. Over SSH it is a different problem, because the run belongs to your login shell. When the connection drops, the shell receives SIGHUP and every process it started dies with it. Hour long runs and imperfect connections meet often.

Start the agent inside a terminal multiplexer so the session outlives your connection:

tmux new -s autoprompt

Press ctrl-b, then d, to detach. Reattach later with tmux attach -t autoprompt and the run is still there, output and all. It also helps to keep the connection itself alive, by adding ServerAliveInterval 60 to the host entry in your local ~/.ssh/config.

What the run does to RAM and CPU while it is in flight

Be precise about where the work happens. The model runs on your provider's hardware, so tokens use none of your memory. Your box pays for the agent process and for everything the lanes actually execute: file searches, compilers, test suites, package installs and containers. That is the load which grows when you open more lanes.

Six lanes each running a test suite is six test suites at once. On a 2 GB server, one Node or JVM test run per lane is how you meet the kernel out of memory killer. It kills the largest process, and the agent disappears with an exit that explains nothing. The evidence is in the kernel log:

journalctl -k --since "1 hour ago" | grep -i "out of memory"

A line reading Out of memory: Killed process 3412 (node) total-vm:... means the box ran out of memory. It does not mean the agent failed the task. Watch the box while a long run is going:

watch -n 5 'free -m; uptime'

If the available column in free -m sits near zero, or the load average from uptime runs far above your core count, lower max_subs before you buy a bigger plan. General sizing is covered in how much RAM and CPU a coding agent VPS needs. Autoprompt pushes that sizing up, because concurrency is the point of the tool rather than an accident of it.

Disk moves too. A lane that installs dependencies or builds an image writes its own copy of them, so a repository with a heavy dependency tree can multiply its footprint during a wide run. Swap keeps a tight box alive instead of killing the run, and it makes everything slower, so it is a safety net and not a fix.

What 2x tokens means on your bill

Two bills move here, for different reasons. The VPS is a fixed monthly price, so a longer run adds nothing there until you size up the plan. The model is metered per token, so double the tokens is double that line.

You do not need a price list to plan for it. Take the token spend of a normal run in your agent and double it, then decide whether the task is worth that. If you are on a subscription with usage limits rather than a per token rate, the same doubling means you reach the limit after half as much work. How token usage is counted is the place to start if those numbers are not visible to you yet, and controlling agent costs on a VPS covers the guard rails worth setting before you run anything unattended.

Autoprompt against the lighter skills

Ask one question of any skill before you install it. How many extra model calls does it add? The answer sorts the whole category.

The unlazy skill's depth tree method and the ponytail lazy senior dev agent work on the agent you already have. They change how one loop behaves, so what they cost you is context and some extra turns. Autoprompt changes how many loops exist. What it costs you is a multiple.

That gives a usable rule. For a bounded change in code you know, a behaviour skill is enough, and it is cheaper and finishes sooner. For the task you would otherwise supervise for an hour, where the failure you keep hitting is an agent reporting success on work that does not run, the separate judge in Autoprompt is the piece you are missing. Installing all three together leaves you with overlapping instructions and no way to tell which one earned the result.

Install Autoprompt v1.0.4

Four prerequisites, and the first two are where installs fail.

• Node.js 20 or newer. The package declares ">=20.0.0" in its engines field, so an older Node is rejected.
• Python 3.11 or newer, reachable under the name python, with the PyYAML library available.
• Bash 4.3 or newer, on macOS or Linux.
• Git, needed only if you install from the repository instead of from npm.

Check all of them first:

node --version
python --version
python -c 'import yaml; print(yaml.__version__)'
bash --version

On Ubuntu and Debian the second command often answers python: command not found on a machine that has Python 3 installed. Those systems ship the interpreter as python3 and create no python name for it, so any helper script calling python fails before it starts. The archive has a package for each half of the problem:

sudo apt update
sudo apt install -y python-is-python3 python3-yaml

Now install the skill, pinned:

npm install -g autoprompt-skill@1.0.4
autoprompt

The first line installs the command line tool. The second starts the installer, which asks which coding agent to install into and confirms the path it found for it. Pin the version. A bare npm install -g autoprompt-skill takes whatever is newest on the day you run it, and a skill that rewrites how your agent works is a poor thing to upgrade by accident. Version 1.0.4 was published on 21 August 2026, and 1.0.0 only three days before it, so this project is moving quickly.

If npm answers EACCES: permission denied on a path under /usr/lib/node_modules, your global prefix belongs to root. Reaching for sudo leaves you with root owned files in a user tool. Point npm at a directory you own instead:

npm config set prefix ~/.npm-global
echo 'export PATH="$HOME/.npm-global/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

Then verify:

autoprompt doctor --strict

A clean report lists each installation the tool detected and raises no failures. Nine agents are audited by the project, each with a minimum version, including Claude Code from 2.1.219 and OpenCode from 1.18.7, which is the harness the benchmark used. Removing it is autoprompt uninstall for the interactive path, or autoprompt uninstall PROVIDER for one agent. The project is MIT licensed.

Running it, and what you should see

/autoprompt fix the failing signup test and add a regression test
/autoprompt mode=custom max_subs=4 build the booking flow from API to checkout

Codex uses $autoprompt in place of the slash, and Oh My Pi uses /skill:autoprompt. Everything after the command, modes included, is your goal in plain language.

A healthy run states its plan before it starts changing files, then works through the phases and reports at each one. It halts and asks you when a decision changes the outcome, when an action needs your permission, or when it meets a blocker it cannot clear safely. A long run on a large goal that never once stops to ask is worth reading closely before you accept its output.

When not to run it

• The change is small and you already know which file to edit. The orchestration then costs more than the work it wraps.
• The box has 2 GB of RAM, no swap, and a test suite that is heavy on its own.
• You are on a metered model and near your budget for the month.
• The repository has no tests. Half of the design's value is a judge that can run something and disagree with the builder on evidence. With nothing to run, the review phase is one more opinion at full token price.

One more thing is worth settling before the first unattended run. An agent opening six lanes for an hour on a box that holds your deployment keys is a risk you can price, and running coding agents in a disposable VM is the cheaper way to hold it.

FAQ

Does Autoprompt really cut coding agent failures by 45 percent?

That figure comes from the project's own Terminal-Bench 2.1 run using OpenCode 1.18.7, where failures fell from 29 tasks to 16 out of 89. The arithmetic is sound and the benchmark is real. It is also one run, on one harness, published by the tool's author. No matching run on a different agent or on your codebase has been published, so read it as evidence that the design helps rather than as a number you will reproduce.

How much does Autoprompt cost in time and tokens?

The project states about three times the execution time and about twice the tokens compared with the same agent without the skill. Its documentation also says timing and token logs from the benchmark were not retained, which makes those two numbers planning estimates rather than measurements. Budget for them regardless: double the token spend you expect for the task, and assume a run you used to watch will now outlast your attention.

What do I need installed before Autoprompt will work?

Node.js 20 or newer, Python 3.11 or newer reachable as python with PyYAML available, and Bash 4.3 or newer. Git is required only for installing from the repository instead of npm. On Ubuntu and Debian the usual failure is python: command not found, because those systems ship the interpreter as python3 only. Running sudo apt install -y python-is-python3 python3-yaml fixes that name and the YAML import together.

Can I run Autoprompt on a small VPS?

Yes, if you cap the concurrency yourself. Each subagent lane runs real work on your machine, including searches, builds and test suites, while the model itself runs at your provider. On a 1 GB or 2 GB server, begin with mode=custom max_subs=2 and keep free -m in view during the run. mode=tokensaver caps lanes at six, which is still six parallel test suites on a box that can comfortably run one.