DocsGetting StartedCore Concepts
Back
Getting Started

Core Concepts

Two systems, one team

Today, humans and AI agents work on the same problems — but off of separate systems.

Humans have issue trackers, Kanban boards, and Agile rituals — tools built around discussion, alignment, and visual workflows. Agents have task queues, context files, and ad-hoc prompts — whatever the developer wires up to feed work into the model.

These systems don't talk to each other. The human plans work in a tracker. The agent reads a markdown file the developer wrote. When the agent finishes, someone manually updates the ticket. There is no shared planning, no shared process, no shared history.

The gap isn't just inconvenient — it's a bottleneck. Developers are now the translators between two systems, manually shuttling context back and forth instead of doing higher-value work.

Bringing both worlds together

Exponential is not another issue tracker or project management tool. It is a full product engineering system for human-agent teams. A single environment that covers the full loop from planning through spec writing, execution, verification, and delivery, for both humans and agents.

An issue tracker manages a backlog. Exponential manages the process: how work gets decomposed, who (or what) picks it up, how specs evolve from rough ideas to implementable briefs, how implementation gets verified, and how results flow back into the next planning cycle.

It meets humans and agents at their native interfaces:

  • Humans work through the CLI and the web board — the familiar Kanban, backlog, and sprint workflow
  • Agents work through the CLI and the MCP server — structured tools designed for machines

Same issues. Same status flow. Same history. The backlog is one part of it — the connective tissue is the workflow that runs through it.

What stays from Agile, what changes

The Agile principles still apply — in fact, they apply more than ever:

  • Small, deliverable increments — you decompose more aggressively because agents work best on tightly scoped specs. And since your agents have full native access to Exponential, managing the backlog is now incredibly cheap and fast.
  • Prioritized work items and Dependencies — your agents get a clear signal about what to work on next, how work items depend on each other and your priorities and preferences.
  • Iterative delivery — you still ship frequently and adapt. Keep epics and stories vague until you are ready to expand them together with your AI agents into specs that are current with actual state of the code base.
  • Sprint rhythm — xpo has built-in cycles with velocity tracking and burndowns, so you can track your backlog and cycle health and immediately spot issues before they become a problem.

What changes is the division of labor. In traditional Agile, a developer picks up a story, figures out the approach, implements it, and submits a PR. With xpo, a human picks up a story, specs it out collaboratively with an AI agent, and hands the implementation off. The human's role shifts from implementing to decomposing, specifying, reviewing. And xpo was purpose-built with this new role of a product manager over a team of AI agents in mind.

What also changes is the cadence. Agents don't need standups to know what to work on — they read the backlog directly. They don't need planning poker — they read the spec and either have enough information to start or they don't. An agent can pick up an issue, implement it, and submit a result in minutes. Your planning rhythm stays; the execution velocity changes.

Issues as code

In xpo, your backlog lives in a special folder inside your git repository — committed alongside the code that resolves it. This has practical consequences you'll feel immediately:

  • Branching works. xpo start <id> creates a feature branch. The issue and the code travel together.
  • History is free. Your issues have the same git history as your code — who changed what, when, and why.
  • Offline works. No server, no network, no latency. Your backlog is local.
  • Merging works. Push, pull, and merge your backlog the way you merge code. No sync conflicts.
  • No vendor lock-in. Your data is in your repo. There is no account, no subscription, no API key.

For the curious, the Architecture page covers how this works under the hood.

From stories to specs

In traditional Agile, a user story describes what the user wants. The developer figures out the how. In xpo, an issue evolves into a spec — it describes what to change, where in the codebase, and how to verify the result. This level of detail is what makes agent execution reliable.

You don't have to write specs from scratch. Start with a rough idea, have your agent draft the spec, and refine it yourself. The agent reads the codebase, asks about constraints, and helps you decompose the work into implementable pieces. See Writing Specs for what makes a spec agents can execute well.

The progression:

  1. Capture — xpo add "Improve auth flow" — a rough idea in BACKLOG
  2. Plan with an agent — discuss, decompose, write acceptance criteria, break into sub-issues
  3. Promote — move to PLANNED when the spec is tight enough to execute
  4. Drive — xpo drive picks it up, refines the spec further, implements, verifies, and merges
  5. Review — check the walkthrough and diff, merge or iterate

What to explore next

Getting started

Working with AI

Issues and planning

  • Issues — creating, editing, and organizing work
  • Parent & Sub-Issues — epics, decomposition, and rollup
  • Relationships — dependencies, blockers, and the dependency graph
  • Status — the issue lifecycle, branching, and merging
  • Cycles — sprints, velocity tracking, and burndowns

The web board

  • Board — Kanban columns, drag-and-drop, and filtering
  • Dashboard — velocity charts, burndowns, and flow metrics
  • Keyboard Shortcuts — full keyboard navigation

Infrastructure

PreviousStarting GuideNextInstallation