An execution engine for coding agents

Agents do the work.
ATask decides what's done.

ATask takes a dependency graph, assigns isolated work to coding agents, and requires fresh proof and regression checks before recording completion.

No ticket board. No model to configure. No command to mark your own work done.

Install ATask See the agent workflow

Local SQLite Worktrunk required No built-in LLM

What the agent runs CLI · abbreviated workflow

# The contract, once per agent
$ atask context
# Claim work whose prerequisites passed
$ atask claim
$ atask context TASK_ID
# Implement and commit in its worktree
# No “status = done”. Prove it.
$ atask verify complete

A task is not done because an agent says so. It's done when the committed revision passes both checks.

Why it is built for agents

Less to learn. Fewer ways to be wrong.

People can negotiate whether a ticket is finished. Coding agents need a smaller interface and a completion rule they cannot bypass with a status update.

01 · Context

Short instructions, clear next action.

atask context gives the operating contract. atask context TASK_ID gives one worker its outcome, checks, workspace and handoff.

No agent-specific planning framework to learn.

02 · Authority

Claims survive agent failures.

One leased claim per task. Stale session tokens lose authority; progress and next steps remain available for the next attempt.

No double-claim by cooperating workers.

03 · Completion

No self-reported success.

Agents can run checks, inspect failures, and retry. Only passing required checks on committed code establish completion.

The engine derives state from evidence.

How execution works

A graph that controls the work.

Bring a plan from any agent or planning tool. Dependencies determine which tasks can run—and which verified revisions their branches start from.

01Plan

Define verifiable outcomes

Import tasks and requires edges. Each claimable task declares proof and regression checks.

atask add -f plan.yaml

02Claim

Give one agent one task

An atomic lease gives an eligible task to a worker in an isolated Worktrunk worktree.

atask claim

03Implement

Build on verified inputs

Dependent branches include completed prerequisite revisions. The agent edits and commits its change.

atask context TASK_ID

04Verify

Complete only with evidence

Both checks run fresh on committed code. Completion unlocks dependent work.

atask verify complete

If B requires A, B cannot be claimed before A completes. Its starting code includes A's verified revision.

A → verified → B ready

The completion contract

Two checks. Both required.

Task checks demonstrate the requested behavior. Regression checks protect existing behavior covered by tests. Each check runs fresh with its own time budget.

ProofRequired

Did this change work?

A focused, executable check for the specific task outcome. Named test presets require a test to actually run.

go_test: ./auth name=TestRejectExpired

Default proof budget 30 s

RegressionRequired

Does covered behavior still work?

A separate check against regressions. Its passing result must come from the same committed revision.

go_test: ./auth

Preset budget or explicit size=

One task, one readable declaration.

The CLI rejects incomplete tasks at claim time. Both checks are attached to the task, not hidden in a human checklist.

atask add "Reject expired tokens" \
  --proof "go_test: ./auth name=TestRejectExpired" \
  --regression "go_test: ./auth"

Time limits for each check30 s · small5 min · medium15 min · largeSee presets ↗

Checks enforce a repeatable gate, not absolute correctness. Meaningful tests are still necessary. size=eternal explicitly removes a check's time limit.

How it fits

Keep your planner. Use a stronger finish line.

ATask is the execution backend beneath your agent workflow, not another place to move tickets between columns.

Beads ↗Issue memory and dependencies

Beads tracks issue state and ready work.

ATask: an executable proof gate decides whether work completed.

Task Master ↗Planning and task decomposition

Task Master turns requirements into actionable tasks.

ATask: accepts the plan and verifies the resulting code.

GSD ↗Agent workflow and verification

GSD structures execution and verification.

ATask: makes completion an engine-level rule independent of the model.

Worktrunk ↗Required dependency

Worktrunk manages task worktrees and merges.

ATask: adds the execution graph, leases, proofs and completion records.

Get started

Install the engine. Keep your agents.

Requires Go 1.24+, Git, and Worktrunk (wt on your PATH). No server or API key required.

Works with the agent you already use.

ATask installs instructions in AGENTS.md and a Claude import. Your planner creates tasks; your coding agents claim and verify them.

CLI + Go APILocal SQLiteModel-agnostic

Read the repository

Verification records completion on the task branch. It does not automatically advance the target branch. Your host can merge verified work with Worktrunk.

In your Git repository

# Install ATask (Worktrunk must already be installed)
go install github.com/zachbornheimer/ai-task/cmd/atask@main

# Initialize agent instructions
atask init
git add AGENTS.md CLAUDE.md .claude/settings.json
git commit -m "Set up atask"

# Configure the project and check setup
atask project --target-branch main
atask doctor

Current main branch · no tagged release yet

Agents do the work.ATask decides what's done.