Concepts

What each building block of the framework is and why it exists. For how to use them, see Workflows, Skills, and Commands.

Data model

The files and structures that make up the framework’s primary state.

• Tasks — Markdown files with YAML frontmatter, one per unit of work.
• Plans — The implementation contract for a task, written and approved before code changes.
• Parent and child tasks — How a complex task is decomposed into siblings that share context.
• Topic anchoring — How loosely related follow-up tasks cluster around a shared subject.
• Folded tasks — How related tasks are merged into a single primary task.
• Task notes — A short message left on an existing task, so whoever works on it next learns something it needs.
• Review guides — Structured prompts that drive batched code review.
• Attachments — Content-addressed files attached to a task, identified by their hash rather than a path.
• Artifacts — Versioned task outputs behind a stable handle; new versions and backend moves never rewrite the task file.

Workflow primitives

The building blocks that shape how skills and code agents behave.

• Execution profiles — Pre-answered workflow questions that switch a skill from interactive to automated.
• Skill templating — How profile-aware skills materialize per-(skill, profile, agent) variants on demand via templated dispatch.
• Verified scores — How user satisfaction ratings accumulate into per-model, per-operation reliability scores.
• Agent attribution — How each task records which code agent and model implemented it.
• Agentcrews — The multi-agent orchestration engine that runs a team of agents as a dependency-ordered crew; the foundation under flows like brainstorm.
• Gates — Named checks a task must satisfy before it archives, and why the enforced set is fixed when the task is picked.
• Locks — How concurrent agents avoid stepping on each other’s tasks.
• Shadow agent — A second coding agent beside a working agent that explains what it is doing and helps you decide — advice only.

Lifecycle and infrastructure

How tasks move through the system and how the repository is laid out.

• Task lifecycle — The status transitions a task moves through from creation to archival.
• Implementation trails — A saved, versioned recommendation of which tasks should land next, in what order, and why.
• Git branching model — The dedicated branches that hold task data, locks, and IDs, and the ./ait git wrapper that routes to them.
• Cross-repo references — Pointing at a task or file in another project by the project’s name, which each machine maps to its own checkout.
• The IDE model — How ait ide turns tmux into a navigable agentic IDE around the monitor TUI.
• Framework session — The machine-wide record of every code agent’s pane, session and freeze state, behind freezing an agent and restoring it.
• Agent memory — How archived tasks and plans become long-term, queryable context for future agent sessions.