meta-kim

Start here

Tell your coding agent what you want. Meta_Kim turns that request into a visible, reviewed, verifiable execution.

Meta_Kim is not a new model and it does not replace Claude Code or Codex. It adds the missing team layer around them: clarify the goal, find the right capabilities, split safe parallel work, review the result, verify the evidence, and preserve useful lessons for the next run.

You say: “Finish the sign-up and login flow. Keep existing users working, split frontend/backend/testing where useful, and tell me exactly what was verified.”

What you actually get

• The thing you asked for: code, a fix, a PR review, a PRD, documentation, or a release-ready change.
• A readable explanation of what changed and why.
• Test and verification evidence, with unknown or unproven claims kept visible instead of being called “done.”
• A local Live control room whose default view is one execution graph, with named sessions, work-item status, AI roles, tool activity, blockers, outputs, evidence, and replay history.

What it looks like while running

The default view is one execution graph: named sessions on the left, the run's dependency graph on the canvas, and an Inspector that holds secondary evidence when you open it. A four-column work board and a project/session repository view are one click away when you want work-item status or project facts instead of dependencies. Historical status-only records are labeled honestly; new runtime projections preserve conversation identity and richer work telemetry.

Recent upgrades on main

What the final handoff looks like

Done      Sign-up, login, token refresh, and error states implemented
Changed   8 source files, 3 tests, 1 migration
Verified  Unit 42/42 · integration 11/11 · build passed
Open      OAuth browser acceptance was not run — credentials unavailable
Next      Connect staging credentials, then replay the blocked check

That summary is backed by the changed project files and run evidence. Meta_Kim does not turn an unavailable check into a green result.

What can it help you make?

The coding runtime still does the domain work. Meta_Kim makes the route, ownership, review, and proof explicit around it.

Try it in 3 steps

1. Install Meta_Kim:

   npx --yes github:KimYx0207/Meta_Kim meta-kim
   

2. Open your project in Claude Code or Codex and ask normally. You do not need to memorize a command:

   Review this project, fix the three highest-impact problems,
   use parallel work where it is safe, and verify the final result.
   

3. See the run. The first governed request lazily starts one local Live Hub and returns the current graph link in the conversation. The manual recovery command remains:

   meta-kim live
   

Good first requests include building a feature across frontend/backend/tests, investigating and fixing a difficult bug, reviewing and improving a pull request, turning a product idea into a PRD and first implementation, or preparing a change for release without hiding failed checks.

In one sentence: Claude Code and Codex are the hands; Meta_Kim is the team structure, quality control, and evidence trail around those hands.

Overview

Meta_Kim is not another AI coding tool. It is a governance layer for durable AI coding work.

Meta_Kim Live: proof you can see

Meta_Kim Live turns durable run records into a local Proof-Carrying Run Graph. One user-level Hub lists explicitly registered Meta_Kim projects, then lets you choose a Session / Run and inspect its stages, owners, evidence, uncertainty, and replay. It never scans the whole disk, reads raw Codex or Claude Code conversations, replaces the agent, creates a second scheduler, or pretends an unverified node is done.

The Hub opens in Chinese by default; use the EN switch in the top-right corner for English. The preference is remembered locally. A marker-backed project joins the catalog when you explicitly open Live for it or start its first governed run, while an existing explicit skip is preserved.

meta-kim live

The Hub binds only to 127.0.0.1, loads no third-party assets, and reuses one process through a PID, process-start identity, and instance-health proof; first use after an update safely replaces an older Hub version. The default surface is read-only; guarded controls are opt-in only with --enable-control and a complete injected authority loadout (durable repository, lease/fence/effect checks, control token, and capable adapter). Without that complete authority chain, the service remains plan-only and fail-closed. Selecting and reopening an observed run is available now; automatic execution resume and cross-runtime handoff remain separate capabilities that require lease/fence and side-effect safety evidence.

M3-L02–L04 sharing and control boundaries

• L02 share/replay: meta-kim live can expose a deterministic local share artifact and replay view. JSON export, PR-card copy (from /api/share?format=markdown), and README embed (from /api/share?format=readme, rendered by the canonical safe renderer) stay on the local machine; there is no upload path. Content-bound SHA-256 is recomputed from canonical content, and the artifact never republishes secrets, absolute paths, raw prompts/outputs, or environment data.
• L03 continuation controls: the page remains read-only by default. Opt in with --enable-control only when the local service explicitly advertises every pause, resume, reassign, and handoff capability and supplies the complete injected authority chain. Commands are authority-bound and fail closed without the durable repository/lease/fence/adapter chain; a request being accepted is not presented as execution success.
• L04 SDK: meta-kim/live-sdk (source: src/sdk/live/index.mjs) is projection-only for runtime adapters, evidence cards, and replay themes. It has no runtime authority and does not claim live-certified status.

Runtime support is intentionally tiered: Claude/Codex are the primary targets; ZCode, DeepSeek Harness, Qoder, and Trae are beta/compatibility paths; OpenClaw and Cursor remain compatibility-only until native adapter evidence exists. Missing adapters fail closed, and this surface is not a live-certified claim.

The hard part of AI coding is no longer getting a model to change files. The hard part is deciding what should happen first, which capability should own it, what evidence proves it worked, and how the lesson survives the next run.

Claude Code, Codex, OpenClaw, and Cursor are all hands: they can write code and change files. But who decides which file to change first? Who reviews the result? Who fixes the problems that show up? And how do we make sure the same mistake does not repeat next time?

Meta_Kim is built for that. It is the governance layer above the coding hands: a runnable set of agents, skills, contracts, hooks, scripts, and evidence gates that keeps complex work from turning into a mess.

One-line summary

First clarify what needs to happen -> then decide who should do it -> review after execution -> preserve what was learned -> feed that back into the next run.

This is not a new concept. Mature engineering teams already do this. Meta_Kim turns it into a runnable system instead of relying on human discipline alone.

Before / After

What 3.0 changes