Everything agf does

Sets agf up in your project: configures it, checks the environment and starts the web dashboard.

Quick orientation that spends no tokens: project numbers, the next task and the skills for each phase.

A friendly index of the commands, with an overview and first steps.

Describe what you want in plain language and get the exact agf command back.

Prints the agf reference guide (tools, skills, phases and gates), optionally filtered by phase.

Checks whether your environment is ready to run agf and points out what is missing.

Updates the agf binary to the latest published version.

Reads, changes or lists the project settings.

Lists, shows and applies ready-made workflow presets, such as default or strict-tdd.

Installs the local model that enables meaning-based search (embeddings) in the project.

Shows the engineering principles that guide agf, grouped by theme.

Lists the project folders you used recently.

Imports a requirements document (.md, .txt, .pdf, .html) into the task graph, with acceptance criteria on each task.

Generates a requirements document with testable acceptance criteria; with --import it becomes a task graph right away.

Creates a project from scratch: from idea to task graph and the first instructions for the agent, in one step.

Creates, shows, changes, moves, clones and removes items in the task graph.

Adds a task, epic, risk or decision to the task graph.

Creates, lists and removes links between items in the task graph.

Links two items, for example saying one task depends on another.

Finds tasks that are too big and suggests how to split them into small parts.

Points out what the plan is missing (criteria, tests, requirements without tasks) and the command to fix each one.

Reusable task breakdown templates: list and apply.

Creates tasks and links from a template, filling in the variables you pass.

Puts the child tasks of an item in a queue, each depending on the previous one, by creation order.

Strengthens weak acceptance criteria by rewriting them as Given-When-Then.

Checks whether existing code already meets a task’s criteria before you build it from scratch.

Plans, reviews and runs the retrospective of a sprint, all recorded in the task graph.

Records the sprint scope, linking it to each included task.

Organizes open risks: promote, accept or close.

Triages open risks; by default it only shows what it would do.

Records questions for a person to answer, and lists, answers or rejects the pending ones.

Checks sprint health (tasks taking longer than expected, parents blocking children) and suggests a replan.

Finds circular dependencies between tasks and proposes how to break them; by default it only reports.

Lists requirements, interfaces and contracts in the graph that no task implements yet.

Suggests graph items to merge, review or retire, using only data already stored.

Merges an exported JSON task graph into the project.

Marks items that are only organizing headings (like “Roadmap”) as not implementable.

Fills in the missing source file on graph items by inheriting it from the closest parent.

Migration tool: moves old acceptance criteria stored as child items into the task itself.

Hands you the next unblocked task to work on, one at a time.

Starts the next task in one step: picks it, gathers context and marks it in progress.

Builds a compact summary of everything the agent needs to know about a task.

Before coding, checks git and the graph to see if someone already did or is doing the same work.

Generates complete instructions for a task to hand to another agent to carry out.

Changes a task’s status (for example, to in progress or done), following the allowed flow.

Runs the tests affected by the current task, or others you choose.

Runs eslint on just the affected files or on the whole project.

Checks the task’s definition of done and whether it followed test-before-code.

Closes the task: checks the definition of done, runs tests, saves what was learned and suggests the next one.

Takes in the result from an agent that worked from instructions, validates it, tests it and closes the task.

Commits only the files declared on the task, without sweeping in other people’s changes.

Lets an external agent report that it started, progressed or finished a task, with validation.

Records or shows which role (implementer, reviewer or validator) is assigned to a task.

Stores and fetches structured subtask results, such as diffs, files, interfaces, decisions and notes.

Puts a task you started but never touched back in the queue; refuses if it already has commits.

Waits until a condition holds (machine has room, merge is free, push is done) without you checking by hand.

Opens the local web dashboard with the task graph and the cost savings tab.

Shows how many items and links the graph has, by type and status.

Draws the Kanban board: status columns, work-in-progress limit and flow metrics.

Opens the interactive terminal interface, with the graph and token usage.

Graph analytics without AI: delivery metrics, bottlenecks and phases.

Forecasts when the backlog will finish, simulating 10,000 scenarios from the real weekly pace.

Shows how long tasks take at each stage and which have been sitting the longest.

Tracks each epic: tasks done, already on main and with proof that it works.

Shows milestone progress: child tasks done, on main and with a passing proof.

One line per epic: the objective, how much of the key results was reached and the status.

Shows the lifecycle phases and detects which one the project is in.

Opens a simple web progress page (graph, tokens and live logs) on the port you choose.

Exports the task graph as JSON, CSV or a Mermaid diagram.

The 5 DORA metrics (frequency, lead time, failure, restore, rework) and first-try success.

Earned value for an epic (CPI, SPI and forecast final cost) from the estimates.

Little's Law per flow stage and the predicted gain if you change the load.

Shows how much time goes to gates, evaluation and retries, per task or overall.

Round retrospective: the 3 biggest bottlenecks and how throughput and lead time changed.

Shows the graph events for your session: tasks done, assigned and merged.

Answers “is it really done?” for a task, showing each piece of evidence behind the verdict.

Runs the gates that say whether the project can move to the next phase (analysis, design, review, deploy and others).

Runs read-only checks: acceptance criteria, readiness, done, integrity and flow.

Scores from 0 to 100 how ready the code is for agents to work on (types, tests, docs, naming).

Runs the continuous integration steps in order and stops at the first failure.

Quality gate over src/: fails if tests and logs fall below 95%.

Quality rules that block or just warn when a metric crosses its limit.

Saved quality checks that run before and after an action, failing open or closed.

Gathers into one list the problems found by quality score, types, security and tainted-data analysis.

Gives a 0 to 100 score for the quality of a task’s tests.

Fails if any source file goes over 800 lines.

Searches the code for shortcuts that hide errors, such as empty catch blocks or “|| []”.

Flags code paths that only run with mock data and that no real code turns on.

Lists features that are built but not connected to anything and creates tasks to connect them; by default it only shows.

When the full test suite is red, organizes the failures into tasks.

Creates one task per broken test file, without duplicating those already open.

Runs real scenarios and produces a scorecard: success rate, cost per success, tokens and time.

Stores evaluation datasets, created by hand or from real runs and decisions.

Runs agf’s self-check, which tests its own code with mutations and properties on a real in-memory database.

Ranks each claim by how well it is backed: claimed, cited, validated or proven.

Moves a task up a proof level, only if the required evidence exists in the graph.

Estimates how many defects are still undiscovered by comparing what two independent reviews found.

Runs every analysis for one lifecycle phase and combines them into one report.

Looks for error patterns in the code and runs a detect-and-recover cycle, keeping a history.

Canary tasks whose criteria are locked to a test, to check agents do not cheat.

Runs the same task several times in separate folders and keeps the one that passed the tests.

Checks what the agent claims it did against the real files and tests.

Suggests the usage proof that tells the code before and after the task apart.

A panel of judges that grade the delivery: brief, votes, status and calibration.

Stops the line when something serious happens and only releases it after the fix.

Classifies a command, path or address as allowed, ask first or denied.

Checks a command before it runs and returns an error when it should be blocked.

Sets per project which actions and resources are allowed, denied or need asking.

Creates, grants, verifies and revokes authorizations for actions that need approval.

Waits for a person to approve the task (through a signal file) before continuing.

Looks up the history of tools the agents called.

Detects the project stack (npm, maven, gradle, go, pip) and runs builds isolated from the rest of the system.

Runs any agent CLI inside a container, with no network and only the declared variables.

Checks whether a shell command can run directly, needs approval or is forbidden.

Checks whether a command follows the file and network access rules.

Shows environment variables filtered by prefix, hiding secrets.

Writes the trust record for a release: hash, signature and VirusTotal result.

Approves a run that stopped waiting for a person and resumes where it left off.

Denies a run that was waiting for approval; the next steps do not run.

Views for whoever leads the colony: what was delivered, what is in progress, blocked or in the backlog.

Shows colony status: delivered, in progress, blocked, priorities and backlog.

Opens the colony from the backlog: creates the isolated project copies and the commands for each session.

Automatic round: refills work, lists idle agents and what is ready to merge into main.

Standup per agent: what it delivered since the last round, what it is doing and what is blocking it.

Builds the reviewer's isolated brief: criteria, diff and receipts, never the executor's account.

Records the independent reviewer's verdict, signed and tied to the exact code version.

Lists merges into main made by worker agents and merges with no identity.

Creates, lists and removes each agent’s isolated copy of the project, all sharing one task graph.

Creates (or reuses) an agent’s isolated copy of the project and returns the ready-made variables.

Merges an agent’s work into main in one call, running types, tests and lint on the touched files.

Removes agents’ isolated copies and branches already merged into main; by default it only shows.

Assigns a task to an agent; that agent’s agf next then hands it this task first.

Shows which agents are holding which tasks right now.

Points out colony bottlenecks (overloaded machine, stalled tasks, idle agents) with the owner and the command to fix them.

Shows colony health and its measurement history.

Lists the colony’s agent types and, for each, the model tier, maximum complexity and task types.

Optional coordination between agents: sessions, resource reservations, messages and voting.

Shows each agent’s live status: heartbeat, locks and current task.

Groups up to N small, unblocked tasks to hand out in one round (read-only).

Takes over the tasks of agents that are no longer running, recording who took them.

Freezes the colony on an epic: agents only get its tasks until you release it.

Sends a message to another agent (or all of them) through the graph, including a stop request.

Takes a mission end to end: research, design, build, integration, review and shipping.

Works through tasks on its own, one at a time: picks, builds, checks the definition of done and closes or asks for help.

From request to delivery: turns text, a file or an image into requirements, a task graph and tested code.

Drives the whole delivery: requirements, graph, task breakdown, autopilot and delivery.

Implements a one-off request in a single run: generates the code, applies it and tests it (via the Copilot SDK).

Runs an agf command on an interval, or repeats until a success rubric passes.

Starts a loop in the background, without holding the terminal.

Runs several agf commands in sequence.

Compound commands that do several operations at once, opening the graph only once (faster).

Runs work in steps and resumes from the last finished step; a step can wait for approval.

Schedules step-by-step runs on a timetable (cron).

Schedules prompts to the agent on a timetable (cron).

Starts step-by-step runs when a signed HTTP call arrives.

Keeps an eye on long runs: status, heartbeat and daily report.

Proposes, adopts and reviews automations by comparing before and after.

A queue for heavy commands, so the machine does not freeze running several at once.

Chooses and shows the model provider (Copilot by default, or OpenAI-compatible services).

Sets the project’s active provider, including the address of a local or remote server.

Chooses or shows the model; with auto, agf picks a suitable model for each task.

One panel: provider, model, cache, tokens, dollars spent and savings.

Running table of input, output and cache tokens and cost saved.

Shows how many tokens each task and session used in automatic mode.

Turns on, turns off and lists the optional token-saving techniques.

Lists each saving technique, whether it is on and how many tokens it has saved.

Shortens tool output before the agent reads it, with filters per command type.

Runs a command and returns its output already compressed (or compresses what comes from stdin).

Shows prompt cache statistics.

Gets back the original text that was compressed, using the code left in its place.

Prints a stored full output byte for byte, by its code.

Connects your GitHub Copilot account for agf to use as a provider.

Removes the saved GitHub Copilot access.

Manually picks a gear from 1 to 4 for model and effort, reflected in the Claude Code settings.

Ready-made work bundles that combine model tier, flow and number of retries.

Turns on, turns off and shows flow, a formula that reduces the context sent to the model.

Suggests, from savings already measured, the confidence level at which context retrieval pays off.

Shows or changes the ponytail level (the mode that asks agents for the simplest solution) and where the value came from.

The agent writes a small program that calls the tools instead of calling them one by one, spending fewer tokens.

A local OpenAI-compatible proxy that applies agf savings and records every call.

Shows the command outputs that still reach the agent unfiltered, so you know what to compress.

Decides how much of a tool output to keep (nothing, a reference or all of it) to look up later.

Exports the approved examples of a task to a file for training models.

Writes, reads, lists, searches and deletes project memories.

Saves a memory, from inline text or from a file.

Lists and shows skills, which are ready-made instructions for agents.

Lists the skills available in the project and in your CLI.

Stored learning: each agent’s performance, agent choice and export.

Suggests which agent should take the task, based on history.

Reads a Claude session, finds where a command failed and then worked, and lists the correction rules.

Measures how often the automatic learning gets its choices right.

Knowledge consolidation cycles inspired by sleep: start, status, history and cancel.

Turns a knowledge text into a structured page, with links and a version.

Brings in memories, decisions and patterns from another project’s graph.

Checks the stored knowledge and points out problems, without deleting anything.

Shares knowledge across projects: registers other projects and pulls in what they learned.

Stores wrong predictions and their corrections so the agent can check them before repeating a mistake.

Keeps execution records, with the steps and the cost and time of each.

Tracks which commands you use most, shows trends and generates automatic shortcuts.

Tidies memory: merges near-duplicate memories and archives unused ones, without deleting anything.

Knowledge base: search and read; proposes and confirms new items but never publishes on its own.

When the queue runs dry, gathers what was left behind: idle ideas, open risks and loose criteria.

Searches the text of task graph items, ranking the most relevant first.

Filters graph items by type, status, parent or text.

Code intelligence: index, search, navigate and measure the impact of a change.

Indexes the project code (functions, classes and who calls whom).

Shows only a file’s signatures, without function bodies: about 10 times smaller than reading it.

Shows what may break if a file changes.

Reads a source file; in aggressive mode it shows only the signatures.

Summarizes a source file in 2 lines, without using AI.

Compares two files and shows the difference compactly.

Shows a log without repeats: identical lines become one with a count.

Runs a command and shows only its errors.

Summarizes the project dependencies per manifest file, without running the package manager.

Shows the status of the configured language servers.

Stores and searches library documentation, and generates living docs from the graph.

Generates agent-oriented documentation from the graph, without spending tokens.

Searches the web via Exa or Tavily, without duplicates and ranked by relevance.

Reads an OpenAPI or WSDL spec and extracts the endpoints and data shapes.

Generates ready code skeletons (class, function, component) for a task, without AI by default.

Internal tool: for a goal, finds a ready output skeleton and fills in the blanks, or generates a new one.

Examines neighboring repositories and compares what they do with what agf already does.

Manages the project principles and checks whether the work follows them.

Architecture decision records: create and list.

Creates a numbered decision record, in markdown.

Generates and validates specs from templates.

Keeps living, versioned specs linked to the tasks in the graph.

Keeps ideas that were deliberately ruled out, so the same thing is not argued again.

Maintains the official domain vocabulary in its own section of CONTEXT.md.

Generates changelog sections from the commit messages in a range.

Builds the technical manual as .docx from the files in docs/manual.

Draws the flow diagram (architecture, steps or lifecycle) of the colony, an epic or the graph.

The points where agf acts on its own during the agent’s work: list, test and discover.

Installs agf’s hooks in Claude Code (session start, before and after each tool, on stop).

Lists the 28 hook points and the module responsible for each.

Creates and lists agent roles, both built-in and project-specific.

Creates a new agent role in the project’s configuration file.

Installs, removes, enables, disables, lists and shows plugins.

Adds git sources and lists the skills and plugins available in them.

Checks how agf would connect to a remote MCP server and whether it needs login, without touching the network.

Shows the current session data: identity, mode, model, run, permissions and events.

Inspects and cleans up agf processes left running in the background.

Publishes the project skills to the public mirror.

Creates, lists and restores backups of the task graph.

Saves a copy of the current graph, internally or to a file.

Takes snapshots of the project files’ state to compare, restore or revert.

Finds and fixes problems in the task graph on its own, saving the result.

Removes orphaned isolated project copies and ai-shadow/* branches.

Lists what the CLI does that the web dashboard does not show yet, by priority.

Internal tool: filters a rules catalogue down to the ones for the project’s language.

Internal tool: computes a fingerprint of a TS/JS file that ignores comments and whitespace.

Internal tool: generates the file with the patterns used to detect secrets.

Bridge to Sentrux: quality scans and gates; requires a running Sentrux server.

Internal tool: prints the planning document for the isolated builds initiative (Wave 12).

Groups recorded failures by cause, one graph item per cause.

Optional telemetry: preview what would be sent, send it, configure it or turn it off.