kungfu

Your agents don't hand off the work. You do.

Every switch means copying context, re-explaining decisions, chasing updates, and checking what got lost. Kungfu keeps the same work moving, no matter which agent takes over.

Use the best Agent when it matters. Use a cheaper one when it does not. Keep the same Work across Codex, Claude, OpenCode, Amp, or your own execution surface.

Kungfu UNGFU™ · Never Guess. Facts Unfold. Why this signature exists.

Kungfu is currently Alpha. On macOS or Linux, install Kungfu and make the kungfu command available with the reviewed per-user installer:

curl -fsSL https://kungfu.tech/install.sh | sh

It does not use sudo or edit your shell profile. Follow the exact PATH step it prints, then open a project and run the deterministic recovery story:

cd your-project
KUNGFU_MOCK_AGENT_SCENARIO=recovery-story kungfu

The built-in Mock Agent needs no provider credentials. It starts 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 rather than a particular model.

For a quicker onboarding check that crosses a question, an approval, and a ready-for-review result in one Attempt, run:

KUNGFU_MOCK_AGENT_SCENARIO=multi-step kungfu

See the installation guide for Windows, higher-assurance installation, explicit version pinning, and troubleshooting.

The Mock Agent covers Work creation and execution. Regular onboarding still needs a supported real Agent for independent review, so this is not yet an end-to-end zero-external-Agent path.

Stay in your current Agent. Paste this sentence into Codex, Claude, OpenCode, Amp, or another Agent that can run local commands:

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.

Start an Agent through Kungfu. Use its familiar native console while Kungfu keeps the Work behind it:

cd your-project
kungfu run codex

Use claude, opencode, or amp instead of codex when that is the agent you already use. Pass a task to create the first Work directly:

kungfu run codex "Prepare the release notes"

When .kungfu/ appears. It is Kungfu's project-local workspace for durable Work and runtime state. Do not delete it or add the whole directory to Git. Ask your Agent to run kungfu agent map --json and follow its workspaceGit policy before staging anything. Most contents stay local; Kungfu never stages, commits, or pushes files for you.

Open the optional global view later. The Kungfu TUI and GUI can show and manage Projects and Work across Agent Sessions. They are sidecar views, not a requirement for every Agent conversation.

Kungfu keeps the Work—not the chat—outside every Agent Session: its objective, progress, evidence, next action, and completion state.

• Work continuity. Change the Agent without losing what was done, what remains, or which Work is continuing.
• Verified project understanding. Declared sources, important omissions, conflicts, decisions, and uncertainty remain visible instead of being guessed.
• Inspectable history. People and Agents can see what happened, what the next action is, and where the supporting evidence came from.
• Completion authority. An Agent can produce a result and its evidence; independent review and Kungfu settlement decide whether Work is complete.

The first visible value should arrive within minutes. The deeper value appears over the following days, when the same Work survives context loss, changed understanding, failed attempts, handoff, and restart.

A Project remembers where related Work belongs. A Work keeps one durable objective and its current truth. An Attempt records what one Agent tried, including failure, without replacing or erasing the Work.

The same Work state is available from native Agent consoles, the Kungfu TUI and GUI, the CLI, and APIs. If another live Agent already owns a Work, Kungfu stops a second writer instead of letting two Agents silently diverge.

Durable Work must answer three questions in order: can it survive a new Agent, can it survive failure, and who is allowed to complete it?

Yes. The first proof isolates continuity: one Work continues across two fresh Agent Sessions without copied chat.

Yes. The second proof moves from mechanism to real failure conditions. Inside a disposable Project, the connection drops, a new process resumes, that process crashes, and both Attempts remain under the same Work.

Work survival is only the first step. If an Agent can declare its own result complete, continuity still is not trustworthy.

Only the governed review and settlement path—not the Agent that did the work. The third proof separates Agent exit, independent review, and Kungfu settlement. An Agent can produce the candidate and evidence; it cannot approve its own Work.

These are bounded exact-artifact demonstrations—not provider rankings, production certification, or authority to complete real Work. See the animation technical specification and auditable evidence.

To enter the Lab yourself instead of watching an artifact, run kungfu agent-work-lab. Its short open → watch/tour → try → test → report journey is documented in the Agent Work Lab guide.

Open the optional terminal view whenever you want the larger Work picture:

kungfu

Getting Started leads to the same Agent-first prompt, so this remains a sidecar rather than a replacement for your familiar Agent interface.

You do not need to learn every Kungfu subsystem before making a bounded change. From a source checkout, give your Agent the task you actually want to complete:

Read `AGENTS.md`. I want to <task>. Use the repository's verified task-context route. Before editing, explain only the concepts, current implementation owners, authority boundaries, and qualification path this task requires.

If you are exploring or evaluating the repository rather than changing it, paste this into your Agent:

Inspect https://github.com/kungfu-systems/kungfu.
Read AGENTS.md first. Explain what Kungfu does and evaluate its architecture.
Give me only the smallest mental model I need; do not make me learn the
repository's full ontology.

For a whole-system explanation, start with the Evolution Map. For a bounded change, Shifu compiles a verified Agent Task Chart and expands it only when the task requires more context. Required omissions, stale authority, and ambiguous routing remain visible instead of being filled by guesswork.

The README stops at the product entry. Detailed implementation, evidence, and claim boundaries live in their own maintained routes:

• Use and understand Kungfu: System Overview, the Documentation Guide, and the complete Documentation Map.
• Build or contribute: Contributing to Kungfu, AGENTS.md, Verified Context for Agents, and runtime surface provenance.
• Verify guarantees and current limits: Contracts, Known Limits, and the KFD support matrix.
• Evaluate release, update, and migration behavior: Upgrade Kungfu and the Exit and version compatibility policy.
• Evaluate the wider ecosystem thesis: the Agent Supply Chain architecture.

Kungfu v4 is publicly available in Alpha. Download the current release artifacts or follow the installation guide. Alpha remains a prerelease channel, not a stable or generally available release; exact support, qualification, and non-claims remain in Alpha Status and Known Limits.

• Product home: https://kungfu.tech
• Developer and agent surface: https://libkungfu.dev
• Issues and questions: GitHub issue forms
• Security reports: SECURITY.md
• License: Apache License 2.0

Kungfu's protocol, release infrastructure, build environments, and public sites are developed in the open:

• Buildchain — auditable build and release infrastructure with verifiable Release Passports.
• KFD — the open engineering standard for reliable action and continuity under uncertainty.
• Build Images — source for the reproducible environments used to build Kungfu system artifacts.
• kungfu.tech source — source for the public product site.
• libkungfu.dev source — source for the developer and agent surface.
• All public repositories — the complete organization-level source map.