Continuity

AI coding agents are fast. Keeping track of their work is not.

Coordinate coding agents without losing the state of the work.

Continuity turns founder input, agent runs, code changes, blockers, decisions, and proof into a shared work graph — so you know what changed, what’s blocked, and what can safely run next. 

npm install -g https://github.com/kevinmanase/continuity-releases/releases/download/v0.3.14/ligence-continuity-0.3.14.tgz
continuity
Install Continuity

Requires Node.js 22.19 or later. Works locally without an account. Email sign-in adds workspace sync.

continuity://execution-state current
before scattered prompts and transcripts
after shared execution state
tracks goals, decisions, blockers, evidence
result cleaner handoffs, safer parallel work

Start with one workflow

Connect your workspace once. Give every agent the current state of work.

Continuity works alongside Codex, Claude Code, Cursor, and custom runners. Agents pull current work context, execute a scoped task, then report back with changes, evidence, blockers, and recommended next steps.

human setup 3 minutes
Run your workspace locally.

Install the CLI and launch the app. Create or select a project and attach its Git repository. Email sign-in adds sync and remote access.

npm install -g https://github.com/kevinmanase/continuity-releases/releases/download/v0.3.14/ligence-continuity-0.3.14.tgz
continuity
agent setup copy markdown
Give your agent the setup brief.

Paste a short onboarding brief into your coding agent so it can install Continuity, verify access, pull its first work item, and report progress back.

Copies Markdown for Codex, Claude Code, Cursor, or another runner.

Preview agent markdown 
# Install Continuity

Install Node.js 22.19 or later and Git, then install Continuity.

1. Install the CLI:
   npm install -g https://github.com/kevinmanase/continuity-releases/releases/download/v0.3.14/ligence-continuity-0.3.14.tgz

2. Open the local app:
   continuity
   Create or select a project and explicitly attach its Git repository.
   Set the goal and review Intake proposals in the dashboard.

3. Install the agent contract from the attached repository:
   continuity skills install core --json

4. Read the current project and next work:
   continuity orient --agent codex --json
   continuity next --agent codex --horizon overnight --compact --json

5. Inspect the selected task:
   continuity agent-context --node <node-id> --agent codex --json

6. In the dashboard, Review task and Approve task, then choose Use my AI session.
   Run its exact claim command and work in the returned directory.
   Commit the changes and use the returned continuity work submit command.
   The app verifies the submitted commit against the reviewed checks.

7. For an unverified handoff note:
   continuity report-delta --node <node-id> --kind annotate --summary "<what changed and what remains>" --evidence "<observed checks>" --json

Rules:
- Preserve the workspace, project, and backend scope returned by orientation.
- If you are not Codex, replace codex in --agent flags with your agent name.
- Reading context or leaving a note does not claim work or complete a task.
- Optional Jev checks use your own CONTINUITY_TYPESAFE_API_KEY in the local app environment. Restart after setting it; no key is bundled.

The execution graph for AI-assisted teams

Every agent run gets a goal, context, evidence, and a next step.

without Continuity manual coordination

Each agent starts from a prompt, transcript, or ticket. Context gets stale, discoveries disappear, and humans have to reconstruct what is safe to do next.

with Continuity shared work state

Every run starts from the current goal, known blockers, recent evidence, and a recommended next step. Completed work updates the shared state for the next agent or teammate.

Shared context

Agents start with the current goal, not yesterday’s prompt.

Clean handoffs

Decisions, blockers, and evidence stay attached to the work.

Verified progress

Each run reports what changed, what was tested, and what should happen next.

Parallel execution

Independent workstreams can run at the same time without stepping on the same node.

Works alongside your project tracker

Tickets track what people planned. Continuity tracks what agents actually changed.

Linear and Jira are useful for planning. Continuity sits closer to execution: it captures run output, evidence, blockers, and the next safe action for AI coding agents.

what changes
Linear / Jira / tickets
Continuity
state

Status depends on humans remembering to update it.

Work state updates from agent runs, reported changes, evidence, blockers, and decisions.

context

Reasoning is scattered across comments, chats, transcripts, and local context.

Goals, decisions, tasks, blockers, follow-ups, and proof stay connected to the work.

next action

A human still has to brief the agent and decide what is safe to do next.

Continuity recommends the next runnable work item and flags blocked or conflicting work.

Recent product proof

From one messy request to three coordinated workstreams.

In a recent end-to-end run, Continuity turned a mobile CEO inbox request into graph placement, session specs, and parallel work kickoff — while preventing duplicate agents from taking the same graph node.

concurrent workstreams 3

Three independent work runs were created and kicked off from the same intake flow.

execution flow Inbox → specs → runs

Continuity converted a high-level request into structured work sessions agents could execute.

measured speedup 2.68×

Parallel execution completed faster than running the same work sequentially in the smoke measurement.

conflict prevention Blocked

A duplicate active work claim on the same graph node was rejected instead of allowing two agents to race.

technical receipt 409

Duplicate graph-node work was rejected with work_run_conflict.

Early founder access

Private beta pricing for teams putting coding agents into real workflows.

For founders and small teams already using AI coding agents on production work. Continuity gives you shared context, clean handoffs, conflict prevention, and execution history across agent runs.

Founder beta $9 / month
  • Hosted shared work graph for one workspace
  • CLI for Codex, Claude Code, Cursor, and custom runners
  • Shared goals, decisions, blockers, evidence, and next steps
  • Parallel work coordination and conflict prevention
  • Run history with reported changes and proof
  • Direct onboarding for early customers

Designed to fit your workflow

Not another project manager. The execution state your agents can inherit.

Replacing Linear?

No. Use your tracker for planning. Use Continuity to capture what agents actually changed, verified, blocked, and learned.

Why not longer prompts?

Prompts help one session. Continuity keeps state across many sessions, agents, and handoffs.

Multiple agents?

Yes. Independent lanes can run together while duplicate active work is blocked before it races.

Who is it for?

Solo founders, technical CEOs, and small teams using coding agents for real product work.

Your local Continuity

Install once. Open the same workspace on every computer.

The app runs on loopback and stays useful offline. Sign in inside the app when you want every project, Intake receipt, focus lane, and execution record to converge for your team.