Keep Codex Fast: Best CLI Tools for Codex users in 2026

What Is Keep Codex Fast?

Keep Codex Fast is a CLI maintenance skill built by vibeforge1111 for people running Codex across long-lived projects, terminals, and chat histories. Keep Codex Fast is one of the best CLI Tools for Codex power users and local-first developers. It ships with three modes — inspect, maintain, and optional repair — so you can measure local drift first and only mutate state when you are ready.

Quick Overview

Who Should Use Keep Codex Fast?

• Heavy Codex users who keep many threads open and want a safe way to inspect local state before anything gets archived or moved.
• Developers juggling multiple repos who need handoff docs, stale worktree cleanup, and log rotation without losing historical context.
• Indie hackers and solo builders who work in short bursts and come back to old sessions weeks later with no appetite for manual cleanup.
• Ops-minded engineers who want a repeatable maintenance workflow instead of ad hoc deletes and mystery state drift.

Not ideal for:

• Teams that never use Codex locally and only need generic workstation cleanup.
• Users who expect automatic self-healing with zero review. Keep Codex Fast is opinionated about handoffs and explicit apply steps.
• People who want transcript deletion. The tool archives and backs up first, and it avoids blind destruction by design.

Key Features of Keep Codex Fast

• Inspect-first workflow — report mode is read-only, so you can see session growth, stale worktrees, large logs, and path mismatches before any mutation happens. That makes it suitable for guarded maintenance on shared or sensitive machines.
• Backup before apply — maintain mode backs up important state first, then archives old sessions instead of deleting them. That matters when you need a recovery path for a bad cleanup run or want to preserve a forensic trail.
• Handoff document guidance — the tool pushes you to create repo-local handoff notes before archiving chats. Those notes capture goal, state, touched files, commands run, open decisions, and next steps, which is exactly what a fresh Codex thread needs.
• Thread metadata repair — the optional --repair-thread-metadata-bloat path can trim oversized SQLite title and preview fields after backup. This targets the pathological case where a huge first prompt gets copied into display metadata and slows thread navigation.
• Worktree and log hygiene — stale worktrees can be moved out of the hot path, and large logs_2.sqlite* files can be rotated. That keeps the active workspace smaller without forcing permanent deletion.
• Dead config pruning — it can remove dead project references in config.toml and normalize Windows \\?\\C:\... path mismatches in local SQLite text fields. This matters if you jump between platforms or keep long-lived local state.
• Process visibility — the report shows heavy Node and dev processes without killing them. That gives you enough signal to decide whether a local server is actually the source of the slowdown.

Keep Codex Fast vs Alternatives

Pick Keep Codex Fast when the problem is local clutter: archived chats, stale worktrees, giant logs, and broken metadata. Pick Claude Context Mode when the bottleneck is prompt structure and context retention during active work, not disk hygiene.

Choose Claude Code Canvas if you want a more interactive coding surface and less maintenance logic. Use OpenSwarm if your workflow is about coordinating agents across tasks, while Keep Codex Fast stays focused on keeping Codex itself from getting bogged down.

How Keep Codex Fast Works

Keep Codex Fast is built around a two-stage safety model: inspect first, then apply only when the operator confirms the state is ready. The script reads local Codex artifacts such as state_5.sqlite, logs_2.sqlite*, session_index.jsonl, and project config files, then classifies what is old, oversized, stale, or disconnected from active work. The core abstraction is not a daemon or service; it is a repeatable local-state audit that can be run from the Codex prompt or directly from Python.

The design is intentionally conservative. In normal use, it reports only and does not write files, move folders, create backups, or mutate transcripts. When you do apply changes, it backs up first, archives instead of deleting, and keeps repair operations behind explicit flags. That makes the tool closer to a maintenance transaction log than a cleanup script, which is useful when you need a reversible path after weeks of accumulated chat history and dev-server noise.

python scripts/keep_codex_fast.py
python scripts/keep_codex_fast.py --details
python scripts/keep_codex_fast.py --apply --archive-older-than-days 10 --worktree-older-than-days 7
python scripts/keep_codex_fast.py --apply --repair-thread-metadata-bloat

The first command generates a read-only report. The second expands the output with raw thread IDs, titles, paths, and process paths when you need surgical detail. The third applies core maintenance, while the fourth targets oversized SQLite thread metadata after backup. Expect the tool to refuse mutation when Codex is still running unless you explicitly wait for exit.

Pros and Cons of Keep Codex Fast

Pros:

• Read-only by default so you can inspect state without risking accidental cleanup.
• Backup-first apply path gives you a rollback story for archiving, log rotation, and metadata repair.
• Explicit handoff workflow reduces the chance of losing context from important repo chats.
• Covers multiple local-state problems including stale worktrees, dead config refs, path mismatches, and oversized SQLite fields.
• Useful on long-running Codex setups where accumulated history becomes a real navigation and performance issue.
• Supports privacy-aware operation because detailed inspection and backups are optional rather than automatic.

Cons:

• Not an automatic cleaner; it expects human confirmation before mutating state.
• Scope is narrow; it is designed for Codex local maintenance, not general workstation optimization.
• Some actions require Codex to be closed, which adds a coordination step before apply runs.
• Metadata repair is opt-in, so huge thread titles and previews will not be trimmed unless you explicitly request it.
• License and release metadata were not visible in the scraped page text, so provenance details are less clear than with a fully packaged release page.

Getting Started with Keep Codex Fast

git clone https://github.com/vibeforge1111/keep-codex-fast
cd keep-codex-fast
python scripts/keep_codex_fast.py

If you are using Codex directly, you can also install it by pasting the repo URL into the Codex skill installer. After the first run, review the report, create handoff docs for any active repo chats you care about, and only then consider --apply. If you are unsure whether a stale worktree or oversized thread metadata is the real bottleneck, start with --details and --backup-only before any mutation.

Verdict

Keep Codex Fast is the strongest option for Codex local-state cleanup when you want report-first safety and reversible maintenance. Its biggest strength is the handoff-and-backup workflow; its main caveat is that it expects operator discipline. If your Codex setup has become sluggish from accumulated chats and workspace drift, this is the right tool to run.