Close the terminal. Keep the work.
Tasks, turns, events, backend sessions, and user decisions are persisted locally and can be rediscovered after restart.
Local-first agent control plane
Agent work should survive the terminal.
IndexQube gives coding agents a durable, permissioned, inspectable place to work—so a closed terminal, a restarted daemon, or a fresh agent never erases the task.
Open development preview · public packaging is being verified
Write task · Codex backend
IQB_0042
Harden task cancellation and add integration coverage.
- 10:42:11 Workspace acquiredOS lock · fencing epoch 08
- 10:42:18 3 paths changedAuthoritative pre/post Git state captured
- 10:42:31 Command boundary reachedDecision committed before execution resumes
Approval requiredAPR_019
go test ./internal/control/...
08Replayable events
03Changed paths
DurableTask + approval state
What the control plane owns
The task, not just the process.
Canonical task stateSQLite-backed history
Guarded writesLocks + fencing
Explicit approvalsDurable decisions
Restart recoveryResume without amnesia
The operating idea
The agent is temporary. The task is not.
Native agent sessions are useful continuation shortcuts. They should never be the only place the work exists. IndexQube keeps its own canonical record of the task, its turns, workspace state, approvals, and evidence.
Writes happen inside a guarded workspace.
Explicit write grants, OS locks, fencing epochs, and durable command or file approvals keep the agent inside a visible contract.
See what happened, not just what the agent said.
IndexQube assembles changed paths, bounded diffs, commands, approvals, cancellations, and the underlying event timeline.
One durable chain of custody
From intent to evidence.
IndexQube owns the lifecycle around the agent process. Each boundary becomes explicit, replayable state instead of terminal scrollback and guesswork.
Create the task
The repository-level goal and selected backend enter canonical local task history before execution starts.
Output · task ID + first turn
Run the agent
IndexQube attaches the native session, streams normalized events, and keeps the workspace lock alive with the child.
Output · events + backend session
Decide the boundary
A command or file escalation pauses the task. The request and your allow or deny decision are committed before work resumes.
Output · approval decision
Assemble evidence
Pre/post Git state is reconciled with agent events. A mismatch is preserved and escalated instead of being quietly ignored.
Output · task evidence
Design rule
Codex sessions accelerate continuation. IndexQube’s task history remains the source of truth when a session disappears.
State over session
One task. Four durable views.
The system keeps execution, workspace safety, history, and evidence related without pretending they are the same thing.
The filesystem and Git describe what exists. SQLite records what IndexQube observed and decided.
Task state mapLocal canonical record
Source of truth
IndexQube task
task · turns
route attempts
lifecycle state
route attempts
lifecycle state
Backend sessionCodex App Server · resume optimization
Workspace stateGit root · dirty baseline · lock · epoch
Replayable event logState · approval · command · cancellation
Task evidenceChanged files · diffs · decisions · timeline
Build in the open
What works now. What comes next.
Development preview. The control-plane foundation is running; public packaging
returns after its release path is verified.
Shipped foundationNow
Durable Codex task loop
Create, inspect, continue, cancel, close, and reopen tasks through the local control API and CLI.
Guarded writes and approvals
Workspace-write execution, lock and fencing guards, plus durable command and file-change decisions.
Recovery and task evidence
Restart reconciliation, lost-session detection, SSE event replay, changed-file evidence, and mismatch escalation.
Verification and security evidence
Strict project recipes, conservative Go, Node, Python, and Rust checks, plus task-scoped security findings persist with severity, redacted evidence, and explicit attention policy.
Next product gatesBuilding
Authenticated local control API
Daemon-scoped authentication before browser surfaces or richer local clients connect to durable task state.
Claude Code backend and handoff
A second orchestrated backend with explicit, deterministic handoff while preserving canonical task history.
A cohesive local interface
Task list, active conversation, approvals, evidence, verification, and handoff history in one attachable experience.
Two complementary planes
Orchestration is the product. Optimization is a capability.
Own the work.
IndexQube’s product center: durable tasks, supervised agent execution, workspace safety, approvals, recovery, and evidence.
- Canonical local task history
- Codex backend with guarded writes
- Lifecycle, approvals, recovery, and evidence
Shape the traffic.
An optional local L7 gateway for advanced workflows: Claude Messages and OpenAI Responses ingress, streaming, caching, telemetry, and context optimization.
- Official-client and request-scoped credentials
- Prompt-cache-aware deduplication
- Local audit and operational telemetry
The safety model is part of the task model.
IndexQube does not extract subscription tokens or persist provider credentials.
Git-root identity, per-path baselines, inherited locks, and fencing epochs guard writes.
Unsafe cancellation or evidence mismatch moves work to needs-attention instead of claiming success.
Development preview
Follow the control plane becoming a product.
IndexQube is being built in the open. Explore the source, current CLI, and implementation gates—without an outdated install promise.
Explore on GitHub ↗ Read the product plan ↗