Your First Initiative

By the end of this article, you will have created an Autobuild initiative from a spec document, watched it decompose into features and executables, and know how to track its progress on the board.

Prerequisites: You have completed What is Autobuild? and Install the GitHub App. GitHub is connected, a sandbox is configured, and you have at least one project containing a spec document — a document that describes what you want Autobuild to build.

What Autobuild does when you start an initiative

When you point Autobuild at a spec document, it reads the spec and creates an initiative — a named container for everything that needs to happen. It then decomposes the initiative into features (logical groupings of work) and executables (individual agent tasks that result in pull requests, documents, or other outputs). Agents start picking up executables immediately.

You end up with a structured, trackable build plan that runs automatically. You monitor it, handle reviews, and merge PRs.

Open your project

Open the project that contains your spec document. The spec should be a document artifact in the project — the same kind of artifact your agent reads and writes during normal work.

If you don't have a spec document yet, you'll need to create one first. A spec can be as minimal as a markdown document describing what to build, the acceptance criteria, and any architectural decisions you want to lock in. Autobuild will use it as the source of truth for decomposition.

Ask the agent to build your spec

In the project's agent chat, ask the agent to start an initiative from your spec. You can say something like:

"Build my spec document" or "Create an Autobuild initiative from [document name]"

The agent will read the spec, propose a decomposition, and create the initiative. Autobuild begins immediately — the empty state in the Autobuild section describes this as: ask the agent to build your spec and it will create an initiative, decompose it into features and tasks, and start working.

If you prefer to create an initiative explicitly through a form rather than through chat, go to Inbox, switch to the Autobuild mode using the toggle at the top of the modal (the title will change to New Autobuild), enter an Autobuild name, describe what Autobuild should work on, select or create a project, and attach your spec document. Click Create task to start. You'll see a Autobuild started confirmation and the initiative will appear immediately.

Navigate to the Autobuild page

Once the initiative is created, go to Autobuild in the main navigation.

If this is your first initiative, the empty state will be replaced by the full Autobuild interface with six tabs: Overview, Pull Requests, Board, Initiatives, Settings, and Issues.

By default, the page opens on the Overview tab. At the top right you'll see a Mine / All toggle that filters the view to your work or all workspace work.

Find your initiative

Click the Initiatives tab. Your new initiative will appear as a card in the Active filter group. The tab filter shows three groups: Active (N), Completed (N), and Planned / Paused (N) — the count updates as work progresses. There's also a Search initiatives field to find initiatives by name or description.

Each initiative card shows:

• The initiative name and its current priority level

• A segmented progress bar that fills as executables complete

• Health chips that summarize the state at a glance:

  • ✓ N done — executables that have completed
  • ⚠ N in review — executables that are in review or paused
  • ● N blocked — executables that are blocked or failed
  • If nothing has started yet, the card shows N planned

• PR pills for open pull requests linked to the initiative

• An Updated [time] timestamp in the bottom-right corner

Click the initiative card to open the full initiative detail view.

The initiative detail view

The detail view opens at /autobuild/initiatives/{id} and shows the full picture of the initiative.

At the top you'll see breadcrumbs: Autobuild > Initiatives > [initiative name]. Below that, the initiative name, its status badge, priority indicator, and any linked project.

The detail view is split into a main column (narrative content and timelines) and a details panel on the right. Key sections:

Main column:

• Initiative narrative — the description Autobuild captured from your spec
• Execution Timeline — features and direct executables organized by output type, status, and latest activity
• Activity Timeline — a log of everything that has happened on this initiative

Details panel:

• Stats — counts of features, executables, completed executables, pull requests, threads, artifacts, and dependencies
• Features — a scrollable list of features decomposed from your spec; each feature is clickable and links to its own detail view
• Direct executables — any executables attached to the initiative that aren't nested under a feature
• Dates and ownership — owner, created date, updated date, and Strategy
• Cost — total credits consumed across all executables

If the initiative is active, you'll see a Pause button in the top-right corner. If it's already paused, a Resume button appears instead.

Track executables on the Board

Go back to the Board tab for a kanban view of all executables across the initiative.

The board has five columns:

Column	What it means
Planned	Created but not yet picked up by an agent
Queued	Queued for an agent to start
In Progress	An agent is actively working on it
In Review	Work is complete, awaiting review
Completed	Done

Click any executable card to open the executable detail panel, where you can see its description, linked PR, associated agent thread, and status history.

At the top of the board you'll find an All Initiatives dropdown to filter executables to a single initiative, and a Group by initiative checkbox that reorganizes cards by initiative within each column.

What to do next

Once executables start moving through the board:

1. Review PRs as they appear in the Pull Requests tab. Each PR is linked to the executable that produced it.

2. Monitor the Board for executables that enter In Review — those need human review before the code merges.

3. If an executable gets blocked or failed, click it to open the detail panel. You can re-queue it, adjust the status, or open the linked agent thread to see what went wrong.

4. To pause the entire initiative (for example, while you re-scope the spec), use the Pause button in the initiative detail view. Resume it when you're ready.

When all executables complete, you can return to the Initiatives tab and mark the initiative complete from its right-click context menu (Mark Complete).