Kungfu Keeps Agent Work Alive Across Codex, Claude, and Crashes

The Problem: Every Agent Switch Loses Context

When you move a task from Codex to Claude, or from a terminal to a GUI, you copy the chat, re-explain decisions, and hope nothing got lost. Kungfu attacks that specific pain. The README puts it bluntly: "Your agents don't hand off the work. You do." The tool keeps the Work, not the chat, outside every agent session. It stores the objective, progress, evidence, next action, and completion state. That means a new agent can pick up where the old one stopped, without you pasting a wall of context. The target user is someone who already lives inside an agent and wants continuity across sessions and tools. It is not for people who want a single all-in-one agent. Kungfu explicitly says it is not a required replacement for Codex, Claude Code, VS Code, terminals, or other agent surfaces.

One Work, Three Concepts: Project, Work, Attempt

Kungfu's data model is simple: a Project remembers where related Work belongs. A Work holds one durable objective and its current truth. An Attempt records what one agent tried, including failure, without replacing or erasing the Work. This separation matters. If an agent crashes mid-task, the Attempt is preserved, but the Work remains intact. The next agent sees the same Work state, now with a record of what failed. The README emphasizes that the same Work state is available from native agent consoles, the TUI, the GUI, the CLI, and APIs. That is a concrete architecture: a shared state store that multiple surfaces read from and write to. The write-lock is the key mechanism. If another live agent already owns a Work, Kungfu stops a second writer. That prevents two agents from silently diverging on the same objective.

Installation and the Deterministic Recovery Story

Installation is a single curl pipe on macOS or Linux: curl -fsSL https://kungfu.tech/install.sh | sh. The installer does not use sudo and does not edit your shell profile. You must follow the exact PATH step it prints. For Windows and higher-assurance installs, the README points to docs/guides/installing-cli.md. After install, you can run a deterministic recovery story without any provider credentials: KUNGFU_MOCK_AGENT_SCENARIO=recovery-story kungfu. The Mock Agent runs the same Work through three consecutive Attempts: a disconnect, a crash, then a recovered delivery. Because the scenario is deterministic, it tests Kungfu's local continuity and recovery path, not a particular model. There is also a multi-step scenario: KUNGFU_MOCK_AGENT_SCENARIO=multi-step kungfu, which crosses a question, an approval, and a ready-for-review result in one Attempt. These are the concrete commands to verify the core promise.

How You Keep Using Your Own Agent

Kungfu does not force you into a new interface. You can stay in your current agent and paste a sentence: "Run kungfu agent brief, then guide me through my first Project and Work. Keep me in my current agent, and use Kungfu as the durable Work layer." That sentence is a literal command from the README. Alternatively, you can start an agent through Kungfu: kungfu run codex, or kungfu run claude, opencode, or amp. You can pass a task directly: kungfu run codex "Prepare the release notes". The agent runs in its familiar native console, while Kungfu keeps the Work behind it. When .kungfu/ appears, it is the project-local workspace for durable Work and runtime state. The README warns not to delete it or add the whole directory to Git. Instead, run kungfu agent map --json and follow its workspaceGit policy before staging anything. Kungfu never stages, commits, or pushes files for you.

Three Proofs That Work Is Durable

The README presents three auditable demonstrations. The first proves Work can survive a new agent: one Work continues across two fresh agent sessions without copied chat. The second moves to real failure: inside a disposable Project, the connection drops, a new process resumes, that process crashes, and both Attempts remain under the same Work. The third proof addresses completion authority: only the governed review and settlement path, not the agent that did the work, can declare it complete. An agent can produce the candidate and evidence, but it cannot approve its own Work. These are bounded exact-artifact demonstrations, not production certification. The README is explicit: they are not provider rankings, production certification, or authority to complete real Work. You can enter the Lab yourself by running kungfu agent-work-lab, which follows an open, watch, tour, try, test, report journey.

Limitations: Alpha, Mock Agent, and Review Dependency

Kungfu is Alpha. The Mock Agent covers Work creation and execution, but regular onboarding still needs a supported real Agent for independent review. That means you cannot yet do an end-to-end path with zero external agents. The README states this directly: "this is not yet an end-to-end zero-external-Agent path." Another limitation is the .kungfu/ workspace. If you delete it or commit the whole directory, you break the durable state. You must follow the workspaceGit policy, which adds friction to every project setup. The write-lock that stops a second writer could also be a problem if you legitimately want two agents to work on the same Work in parallel; Kungfu prevents that by design. Finally, completion authority is not automatic. You need an independent review and a Kungfu settlement step. That is a governance burden, not a plug-and-play feature.

Alternatives and the Trade-off in Approach

The obvious alternative is to keep using your agent's built-in session memory, like Codex's or Claude's conversation history. That approach is simpler: no extra tool, no .kungfu/ directory, no write-lock. But it fails exactly when you switch agents or when a session crashes. The chat history is tied to one session and one provider. Kungfu's approach is different: it externalizes the Work into a durable state store that any agent can read and write, with a lock to prevent divergence. Another alternative is a manual handoff document, where you write a summary and paste it into the next agent. That is free and works, but it is error-prone and does not track Attempts or evidence. Kungfu gives you a structured, inspectable history instead of a free-form note. The trade-off is clear: you gain continuity and auditability, but you pay for it with setup complexity and a governance step for completion.

Maintenance, License, and Upgrade Cost

Kungfu is licensed under Apache-2.0, which is permissive for commercial use, but this is not legal advice. The project is actively developed; the default branch is dev/v4/v4.0, and the latest release is v4.0.0-alpha.3, pushed on 2026-08-24. The rapid release cadence, with alpha.2 and alpha.3 in the same month, suggests the API and CLI may change between versions. The README mentions explicit version pinning in the installation guide, which is a sign that upgrades are not guaranteed to be seamless. You should expect to update the kungfu binary and possibly re-run the installer when a new alpha lands. The .kungfu/ workspace format could change between alpha releases, so you must verify that your existing Work survives an upgrade. The documentation includes a technical specification for auditable evidence, which is a maintenance cost in itself: you need to keep that pipeline working if you rely on the proofs.

Editorial conclusion

Adopt Kungfu if you regularly switch between Codex, Claude, OpenCode, or Amp and lose context on every handoff, or if you need a durable record of what an agent did and why. Do not adopt it yet for production work: it is Alpha, the Mock Agent is not a real provider, and the README states that independent review and Kungfu settlement, not the agent, must decide completion. Before relying on it, verify that the .kungfu/ workspace policy matches your Git workflow, run the deterministic recovery story with KUNGFU_MOCK_AGENT_SCENARIO=recovery-story, and test how the write-lock behaves when two agents touch the same Work. Kungfu's value is real but bounded: it preserves Work, not chat, and it cannot approve completion by itself.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes