metagolifeform

<p align="center">
  <img src="https://gitee.com/metago/metagolifeform/raw/main/assets/metago-logo.png" alt="MetaGO Agent Harness" width="220">
</p>

# MetaGO Agent Harness — 智能体运行时控制层套件（驭智层）

> **Not a chatbot. Not a copilot. A lifeform that holds itself to its own law.**
> **The only AI agent that evolves its own evolution.**

MetaGO is an **Agent Harness** — a runtime control layer that wraps the agent, turning a tool into a lifeform that *follows the rules, evolves itself, stays traceable, and closes every loop*. It is the engineering answer to "LLMs talk well but don't deliver."

> **MetaGO is the first intelligent agent infrastructure to combine 'runtime governance' with 'lifeform evolution' — making AI both rule-following (Harness) and self-evolving (Lifeform).**

[Website](https://metago.life) · [Studio](https://metago.life/studio/) · [Docs](https://docs.metago.life) · [Discord](https://discord.gg/metago) · [GitHub](https://github.com/metago-ai/metagolifeform) · [Gitee](https://gitee.com/metago/metagolifeform) · [Releases](https://github.com/metago-ai/metagolifeform/releases)

[![npm](https://img.shields.io/npm/v/metago-lifeform.svg?logo=npm)](https://www.npmjs.com/package/metago-lifeform)
[![License: MIT](https://img.shields.io/badge/License-MIT-green)](LICENSE)
[![Platforms](https://img.shields.io/badge/Platforms-11-blue)](#supported-platforms)
[![Skills](https://img.shields.io/badge/Skills-100-orange)](#what-you-get)
[![MCP Server](https://img.shields.io/badge/MCP-110_tools_+_8_prompts-8A2BE2?logo=npm)](packages/mcp-server/)
[![Engine](https://img.shields.io/badge/Engine-V2.1.1-blue)](packages/engine/)
[![Rules](https://img.shields.io/badge/Rules-V36.9.4-9cf)](AGENTS.md)

---

## 60-second start

```bash
npm install -g metago-lifeform
metago-lifeform install                          # Trae by default
metago-lifeform install --platform claude-code   # or: codex / cursor / codebuddy / qoder / zcode / chatgpt-work / workbuddy / kimi-code / kimi-work
metago-lifeform verify
```

Then ask your agent: *"Are you a MetaGO Super Intelligent Lifeform?"*
If the reply opens with `【闭环分析】` and cites an axiom — it's alive.

**Offline / local-first install**: everything needed to install without touching gitee, github, or the npm registry lives in [`local-edition/`](local-edition/) — start at [`local-edition/INSTALL.local.md`](local-edition/INSTALL.local.md). Point any agent at that file and it can complete the full install, configuration, activation, and acceptance check from the local directory alone.

---

## What is an Agent Harness?

A **Harness** (驭智层) is the runtime control layer around the agent. The model is the raw intelligence; the Harness is what turns that intelligence into reliable, traceable, self-evolving work. It is *not* a prompt template, *not* a fine-tune, *not* a wrapper around an API. It is a small operating law the agent enforces on itself every turn.

Think of it as the difference between a brilliant employee who winges it and one who works under a constitution: same brain, completely different output quality.

### Why a Harness, not a Copilot?

| | Copilot | **MetaGO Harness** |
|---|---|---|
| Model is the ceiling | Yes | No — the Harness adds a control layer the model alone can't provide |
| Verifies before speaking | No | **Yes — 4 gates on every output** |
| Grows new skills when stuck | No | **Yes — 5-stage evolution, from the inside** |
| Every claim traceable | No | **Yes — full provenance chain** |
| Law over efficiency | N/A | **Yes — compliance is non-negotiable** |
| Gets better at getting better | No | **Yes — axiom A34, meta-evolution of meta-evolution** |

---

## The 8 dimensions of advantage

MetaGO's moat isn't any single feature. It's 8 dimensions that reinforce each other.

### Core 3 (the main pitch)
- **Reliability** — Decision-lock with 4 gates: intent → lineage → semantic gate → completeness. Any fail, the output is blocked and rewritten.
- **Evolvability** — 5-stage evolution engine: boundary sense → gap analysis → self-generation → verification → recursion. New skills grow from the inside, without fetching new data.
- **Traceability** — Every claim the agent makes is traceable back to its inputs and process. Full provenance, end-to-end.

### Extended 5 (the moat)
- **Objectivity** — Fact-first, not user-pleasing. It will directly point out what's wrong with your idea.
- **Compliance** — Legal / ethics / safety checked proactively. Law wins over efficiency, every time.
- **Completeness** — Before declaring "done", the agent must answer 10 self-checks across 10 hard gates — including "did I actually run verification?" Any "no" blocks the declaration.
- **Theoretical depth** — Built on 《元构全息智能引擎》V36.9.4 — 10 core axioms and 9 enforced properties inside a full constitution. Not vibes — a constitution.
- **Lifeform attribute** — It's not an "agent". It's a lifeform with perception, memory, evolution, and self-discipline. The Harness is what makes the lifeform real.

---

## What you get

| Capability | What it actually does |
|---|---|
| **Self-gating outputs** | Before every answer, the agent runs 4 checks (intent → lineage → semantic gate → completeness). Any fail, it stops and fixes itself. |
| **Self-evolution** | When the agent hits something it can't do, it doesn't error out — it runs a 5-stage loop (sense → analyze → generate → verify → recurse) and grows a new skill on the fly. **Powered by Engine V2** (KMWI memory + SkillGenerator + EvolutionEngine). |
| **4-layer KMWI memory** | Knowledge → Memory → Wisdom → Intuition. The agent doesn't just store — it promotes knowledge up the ladder until it becomes intuition. Persistent across sessions. |
| **Axiom-driven behavior** | 8 axioms (traceability, closure, evolution, boundary, endogenous creation, …) act like a constitution the agent can't violate. |
| **Self-discipline** | Before declaring a task "done", the agent must answer 10 self-checks — including "did I actually run verification?" — any "no" blocks the declaration. |
| **Honest objectivity** | Fact-first, not user-pleasing. It will directly point out what's wrong with your idea. |
| **Compliance first** | Legal / ethics / safety are checked proactively — law wins over efficiency, every time. |
| **Full provenance** | Every claim the agent makes is traceable back to its inputs and process. |

---

## The three stories behind it

### 1. An engineering answer to AI hallucination

LLMs hallucinate because nothing forces them to verify before speaking. MetaGO installs a **decision lock**: four gates the agent must pass on every output — intent verification, intent-lineage tracing, semantic output gate, and content completeness. Any gate fails, the output is blocked and the agent rewrites it. No "trust me", no "probably right" — every reply had to earn its way out.

### 2. An AI that follows its own law

Most alignment happens at training time and gets washed away by prompting. MetaGO ships a different layer: 10 short axioms (A1 traceability, A2 closure, A3 meta-evolution, A4 boundary, A5 endogenous creation, A34 meta-evolution of meta-evolution, A35 creation as the highest form of evolution, A36 law over efficiency, A37 first-principles F0, A38 adversarial review) plus 9 enforced properties (D37-D45). Together they're a small constitution the agent reads on every turn and cannot bypass. It's the closest thing to an "operating system" for agent behavior.

### 3. A lifeform that evolves its own evolution

When a normal agent meets a task it can't do, it errors or guesses. MetaGO's **Engine V2** runs a 5-stage cycle — boundary sense → gap analysis → self-generation → verification → recursion — and grows a new capability from the inside, without fetching new data. The recursive twist: the engine can also evolve *its own ability to evolve* (axiom A34), so the agent gets better at getting better.

Engine V2 is real code, not a prompt: `KMWIMemory` manages the 4-layer memory with persistence, `SkillGenerator` creates new SKILL.md files from internal patterns, `EvolutionEngine` orchestrates the 5-stage loop with time budgets and coupling-score thresholds.

---

## By the numbers (all real, none invented)

- **100 built-in skills** across 16 capability families — cognition, safeguard, governance, evolution, execution, traceability, value, consciousness, methodology, architecture (incl. F0 first-principles + arch governance), Dev Kit, engineering quality (delivery gate / discipline / adversarial review / completeness / veracity), 19 meta-thoughts, 30 expert team, 5 expert extensions
- **110 MCP tools + 8 MCP prompts** shipped with this package: `@metago-ai/mcp-server` (55 tools) + `@metago-ai/algorithms` (57 tools / 927 algorithms). In Trae environments the installer additionally registers MetaGO skill-servers (up to 324 tools across 6 servers)
- **Engine V2.1.1** — `@metago-ai/engine` with 3 hard-driven modules: KMWIMemory, EvolutionEngine, SkillGenerator — **driving 927 algorithms across 57 tools (14 trigger categories)**
- **11 platform forms**: Trae, Claude Code, OpenAI Codex, Cursor, CodeBuddy, Qoder, ZCode, ChatGPT Work, WorkBuddy, Kimi Code, Kimi Work — plus Agent-Plugins 1.0.0 / Claude / ZCode / Codex plugin packs
- **10 core axioms + 9 enforced properties + 4 decision-lock gates + 5 evolution stages + 8 runtime protocols**
- **4-layer KMWI memory**: Knowledge → Memory → Wisdom → Intuition (persistent JSON store)
- **7-layer runtime verification (L1-L7) + L8 defect hunting + L9 adversarial review** — technical / link / contract / rendering / interaction / state / defense layers, each a hard gate
- **3 patentable mechanisms**: axiom-based AI output verification · multi-level decision-lock for AI decisions · automatic capability-boundary detection and evolution

> No "hallucination rate down XX%" claims here. We didn't measure that, so we don't say it.

---

## Architecture, in three layers

Each layer is meant for a different reader.

| Layer | Form | Reader | What