AICTX - Operational continuity for AI coding agents

Repo-local execution state for coding agents

Operational continuity for AI coding agents.

AICTX helps Codex, Claude, GitHub Copilot and other coding agents continue work across sessions by preserving the last useful execution state: active work, next actions, decisions, failures, validation evidence and repo context.

The next agent starts from what actually happened, not from zero.

Start in 2 minutes<br>See Continuity View<br>View on GitHub

resume → work → finalize<br>pip install aictx<br>aictx install<br>aictx init

aictx resume --repo . --task "continue parser work" --json<br># agent works<br>aictx finalize --repo . --status success --summary "parser tests updated" --json

Disconnected sessions are the problem.

Coding agents can reason through code, but every new session often starts operationally cold: it has to rediscover the repo, infer the task state, avoid old mistakes and guess which validation matters.

Without AICTX

A new agent session starts cold.<br>It scans README, docs and Makefile.<br>It rediscovers decisions.<br>It may repeat failed commands.<br>It guesses what should happen next.

With AICTX

The agent loads a resume capsule.<br>It sees active work and next action.<br>It sees known failures and validation path.<br>It finalizes factual evidence for the next session.

What carries forward?

Work State

The live unfinished task: goal, hypothesis, active files, risks, next action and recommended commands.

Handoffs and decisions

What the previous session left behind and which project decisions should not be rediscovered.

Known failures

Observed failed commands, tests, builds and resolutions that may matter to the next session.

Execution contracts

Expected first action, edit scope, validation command and compliance signals for audit-only continuity.

RepoMap hints

Optional structural entry points so the agent knows where to look first.

Continuity View

A local Markdown and Mermaid map of the operational continuity your next agent will use.

Inspectable, not hidden.

AICTX stores continuity in repo-local artifacts under .aictx/. It is not hidden provider memory and it is not a vector database. You can inspect what was recorded, clean it up and optionally share a safe subset through Git.

aictx view --repo .

# writes:<br>.aictx/reports/continuity-view.md<br>.aictx/reports/continuity-map.mmd

Works around the agents you already use.

Codex

A repo-local continuity loop for sessions that can run CLI commands and consume structured output.

Codex continuity →

Claude Code

Project instructions and runtime artifacts for handoffs, failures, decisions and execution summaries.

Claude Code continuity →

GitHub Copilot

Instruction and prompt surfaces for best-effort lifecycle adoption where command execution is available.

Copilot continuity →

Browse the documentation

The home page is the social entry point, but every major GitHub Pages document should also be reachable from here.

Start

Quickstart

Installation

Usage

Demo

Technical overview

Operational continuity

Continuity View

Work State

Execution Contracts

Execution Summary

Handoffs and Decisions

Failure Memory

Strategy Memory

Area Signals

RepoMap

Use cases

Use cases overview

Codex continuity

Claude Code continuity

GitHub Copilot continuity

Comparisons

Comparisons overview

AICTX vs AGENTS.md

AICTX vs long context

AICTX vs vector databases

AICTX vs chat history

Concepts

Concepts overview

Operational continuity

Repo-local continuity

AI coding-agent memory

Local memory for AI coding tools

Failure memory

Project identity

Official AICTX

Official project

Safety

Limitations

Operations

Portability

Doctor diagnostics

Cleanup

Upgrade

Machine-readable

llms.txt

llms-small.txt

llms-full.txt

sitemap.xml

What AICTX is not

AICTX is not an autonomous coding agent, a cloud memory service, a dashboard, a vector database or a replacement for human review.

AICTX does not guarantee correctness, productivity gains, token savings or that every agent will follow the lifecycle perfectly.

Start from continuity, not from zero.

Install once, initialize the repository, then let each supported agent resume from operational evidence and finalize what happened for the next session.

Quickstart<br>Installation<br>Technical overview