Agent‑Body

An organ‑based plugin layer for DeepSeek Harness: organs, nerve impulses, a heartbeat, reflex arcs, long‑term memory, and closed‑loop self‑healing.

Plugins here are not a tool list. They are organs in a living system.

Architecture · Organ Catalog · Benchmark · Roadmap · 中文文档

Why this exists

Every agent framework eventually becomes the same thing: a pile of tools, a growing list in the system prompt, and an agent that forgets everything between sessions.

It re-reads the same failure twice before learning it exists. It cannot tell you which of its own capabilities are broken. It has no idea that a plugin it depends on went offline — it just calls it and fails. And you keep paying tokens for tool schemas nobody calls.

Agent‑Body takes the opposite bet: treat the plugin system as an organism.

Every plugin declares itself an organ — with capabilities, senses, and reflexes. Everything else is physiology: a nervous system that routes your commands to the right organ, a heart that pumps state through the whole body on a rhythm, reflex arcs that fire without a single model call, and a healing loop that attributes every failure before it even thinks about retrying.

The result is a system that gets measurably better the more you use it, and that stays standing when you rip parts of it out.

What makes it different

🫀 It has a heartbeat, not a loop

A real pacemaker runs at a 1s base clock with a variable interval — 3× faster on critical alerts, 2× on fatigue, 2× slower when the body has been silent for a long while. Every beat packages the current operator directives, the body's proprioception and the homeostasis warnings into a blood packet, writes it to bloodstream.json, and broadcasts it as organism/heartbeat. Any organ can hook the circulation with one line:

ctx.on('organism/heartbeat', (blood) => { /* your organ now has a pulse */ })

Circulation is a loop, not a firehose: organs return blood through organism/venous, and newly learned knowledge is oxygenated (organism/oxygenated) before it is pumped system‑wide.

🧠 Your sentence becomes a nerve impulse

You type a command. Before the model even reasons about it, agent/pre-step converts it into an impulse, deterministically innervates the organs that should handle it, and broadcasts on organism/impulse — telling each organ which of its capabilities to use.

Then the body learns the route. When an innervated organ actually delivers, a Hebbian synapse strengthens "this kind of command → that organ"; when it fails, the weight decays. Dispatch order reorders itself from experience, persisted in synapses.json.

you:  "抓取这个站点并抽取结构化数据"
impulse → sensory(web-crawl) · executive(plan) · immune(verify)
        → each organ told which capability to fire

🩹 Self‑healing is a closed loop, not a slogan

failure → deterministic attribution → prescription → RE‑CHECK

Attribution is not guessing: tool_missing / arg_error / permission / timeout / network / not_found / conflict / unknown. The prescription table decides the response — read‑only remedies execute automatically, side‑effecting ones wait for the brain to rule, and arg_error is never auto‑retried (retrying a wrong argument just amplifies the mistake).

The wound only closes when that organ next succeeds — the system does not declare itself healed. Anything still open after 5 minutes is marked chronic and stops spinning.

Measured on the development install: 21 wounds healed · 100% heal rate · 0 chronic. An arg_error wound closed 3.5s after the underlying fix landed.

🌱 It trains itself — and forgets on purpose

Three learning channels run continuously, none of them requiring you to teach anything:

1. Synaptic learning — success reinforces "command class → organ", failure weakens it.
2. Reflex self‑authoring — the same tool × cause failing 3 times makes the system write its own reflex arc (R-auto-<cause>-<tool>), which then fires automatically on the next occurrence.
3. Chain crystallization — any cross‑organ chain that completes with ≥3 steps is fixed into a replayable skill.

Forgetting is equally deliberate: synapses decay on a 30‑minute half‑life and get pruned below |w| < 0.2; reflexes that fired ≥5 times with zero contribution are retired; skills that keep failing are forgotten.

body_heal action=rehab restores an organ to its healthy baseline — damage cleared, wisdom kept: fatigue and wounds reset, learned synapses, reflexes and skills untouched.

💤 It sleeps, consolidates, and remembers

Idle for 2 minutes → light sleep. 5 minutes → deep sleep, and every 2 minutes of deep sleep runs a consolidation pass with zero model calls — pure deterministic rules mining the experiences of the day into long‑term memory:

New commands trigger deterministic recall — tags > title > body, multiplied by weight — and the most relevant cards are injected into context. Unused cards decay on a 168‑hour half‑life and archive instead of being deleted.

🪶 Zero‑residence context

Instead of lossy LLM summarization, the engine replaces resident content with deterministic pointers — and every masked byte stays recoverable verbatim from the session log:

🧩 Organs are optional — the architecture is not

Six kernels depend on no single organ: nerve bus · heart pump · directive layer · reflex engine · dissector · impulse conduction.

Unplug a plugin and the body keeps running. Uninstalling dsh-office-docs was detected immediately — the craft organ went offline and its capability was compensated by the closest overlapping organ, core integrity still green. An organ that is not installed at all is reported as not installed, not as broken — which eliminated a 15‑second warning storm from a phantom organ.

📉 Token economy as a first‑class concern

Tool schemas are shown on demand, gated by what the current turn is actually about.

Scope of every number below: the tool‑schema block of the prompt only — the name + description + JSON‑schema of every tool definition. Not the system prompt, not conversation history, not tool results.

84.7% of tool‑schema tokens gated away — 55,154 → 8,433 on average across 48 representative commands (median 85.7%, worst case 75.2%), out of 256 capability definitions. Everything else stays one body_call away.

That number is produced by the benchmark in this repository and is reproducible on your machine:

npm run bench          # regenerate benchmarks/results/REPORT.md
npm run bench:check    # exit non‑zero if it drifts from the committed baseline

Two honest caveats, because the headline is easy to over‑read:

• Cold‑start scope. The figure above assumes the body has no recent activity — only the current command decides what is revealed. On a body with real run history, recently‑used and high‑trust organs stay hot, the visible set grows, and savings drop: 74% in the live snapshot committed at benchmarks/corpus/trace-live-gate.json (64 of 256 capabilities visible). Historical README revisions quoted 82% — a single live snapshot between the two. Both extremes are real; always quote the scope with the number.
• 10 of 48 commands need a second hop. A per‑organ cap of 10 capabilities means large organs (the attack organ has 49) get truncated, and a few intents do not route to the organ that owns the capability. Those resolve through body_call, but they are not free. The benchmark classifies every miss as bug / capped / unrouted and lists them individually in benchmarks/results/REPORT.md.

The five biological layers

Every layer is observable: body_map (organs + systems), body_cell (cells + tissues), body_status (vitals). Undeclared plugins are auto‑promoted to autonomic organs — on the development install, 256/256 capabilities were claimed, zero orphans.

Architecture at a glance

graph TD
    OP([Operator command]) -->|nerve impulse| NERVE["body_nerve · innervation"]
    NERVE --> BUS{{"organism/impulse"}}
    LAW(["Operator directives"]) --> HEART
    HEART[["Heart · organism/heartbeat"]] --> BUS
    BUS --> ORGANS["organs · capabilities"]
    ORGANS -->|"tools/result"| REFLEX["Reflex arcs · zero tokens"]
    ORGANS -->|failure| HEAL["Self-healing · attribute → prescribe → re-check"]
    ORGANS -->|experience| CORTEX["Cortex · sleep / consolidate / memory"]
    CORTEX -->|"recall"| ORGANS
    HEAL --> VITALS["Vitals · vitals.json"]
    VITALS --> HEART
    ORGANS -->|venous| HEART

Full detail — three kernels, five life mechanisms, event contracts, on‑disk state, verification methodology — lives in ARCHITECTURE.md.

Organ catalog

Every entry below is a real plugin under workspace/plugins/. Five core organs ship a full offline regression suite (see Verify it yourself); the remaining organs are exercised through their replay scripts.

Quick start

See it work first — no install, no host, no API key

git clone https://github.com/1420079678-ctrl/agent-body && cd agent-body
npm run demo      # command → impulse → dispatch → execute → attribute → reflex fires
npm run check     # constant tables + catalog + 29 tests + benchmark, all offline

There is nothing to install. The core packages import nothing outside Node built‑ins, so the demo runs a real end‑to‑end chain against the committed 256‑capability corpus on a fresh clone.

Then read benchmarks/results/REPORT.md to see how the token claim was measured, and ROADMAP.md to see what is deliberately not being built next.

Install an organ in one command

The self‑contained organs ship a prebuilt tarball on the release page — no clone, no build step. The package declares dsh.bundle, so installing it also appends it to dsh.profile.bundles and the next start mounts it:

dsh plugin --profile web add https://github.com/1420079678-ctrl/agent-body/releases/download/v0.1.0/dsh-external-dsh-organism-0.1.0.tgz

Ten organs ship this way — the ones that need no external toolchain. Append the tarball name to the release URL:

Install the body kernel plus the memory organ:

$rel = "https://github.com/1420079678-ctrl/agent-body/releases/download/v0.1.0"
dsh plugin --profile web add "$rel/dsh-external-dsh-organism-0.1.0.tgz"
dsh plugin --profile web add "$rel/dsh-external-dsh-cortex-0.1.0.tgz"

The rest of the catalog needs a host-side toolchain (a compiler, a browser, or external binaries) and is installed with its replay script instead — see the catalog section below.

Or work from source

This repository is the organ layer — it does not vendor the host. Two pieces, both public:

# 1) the host: DeepSeek Harness itself
git clone https://github.com/deepseek-ai/deepseek-harness.git
#    follow that repository's build/run instructions; note where the checkout lives

# 2) the organs: this repository
git clone https://github.com/1420079678-ctrl/agent-body.git

Point the tooling at your host checkout, then bring an organ online. Each organ ships a replay script that links its dependencies, compiles it, runs its offline regression, and tells you how to inject it:

$env:DSH_CHECKOUT = "C:\path\to\deepseek-harness"

pwsh -File agent-body\workspace\plugins\dsh-organism\scripts\replay-organism.ps1

Replay scripts are idempotent — re-run them after a host upgrade to restore the organ. The same shape works for every organ in the catalog (replay-cortex.ps1, replay-web-crawl.ps1, …).

Once injected, the first three commands to try:

body_status                 # full vitals: organs, fatigue, homeostasis, integrity self-check
body_map                    # the anatomy — which organ owns which capability
body_nerve action=send text="<your command>"   # route a command before executing it

Verify it yourself

Everything below runs offline and deterministically — no network, no model, no API key, nothing installed.

npm run check     # the gate CI runs: constant tables + catalog + tests + benchmark, all in one
npm run demo      # five-minute end-to-end: command → impulse → dispatch → execute → attribute → reflex
npm run bench     # regenerate the token benchmark (writes benchmarks/results/REPORT.md)

npm run check is the honest one. It fails if the zero-dependency core drifts from the real kernel's constant tables, if the organ catalog drifts from source, if any test fails, or if the benchmark moves off its committed baseline. All of it runs on a fresh clone with no npm install.

Organ regressions need the host runtime

npm run verify          # repository health check (structure, JSON, links, secret hygiene)
npm run verify:organs   # run every organ's offline regression

Each organ's suite loads its built lib/, which imports the host runtime (@deepseek-ai/dsh-*). On a bare clone that does not resolve, so the runner reports SKIP with the reason — never a silent pass:

SKIP  dsh-organism/smoke-test.mjs      缺少宿主运行时 @deepseek-ai/dsh-tools
SKIP  dsh-web-crawl/selftest_local.py  缺少 Python 依赖 trafilatura

Inside an installed harness the same command runs them for real. Measured there:

Two of these were red when this table was first written, and the failures were real:

• dsh-zero-residence reported 13 passed / 3 failed. Root cause: session lookup matched by substring and returned whichever directory the filesystem happened to yield first, so computeLedger('session-a') could read session-a-extra's log and report T = 0 instead of T = 2. Fixed with exact-match-first resolution.
• dsh-war-bridge reported FAIL whenever no sample PE was present, because "skip" was recorded as a failed assertion — and process.exit() racing an in-flight AbortSignal.timeout tripped a libuv assertion that turned a green run into exit code 1. Both are fixed; a skip now says so.

The core packages are covered by npm test: 29 assertions, 0 failures, including a parity suite that compares the dependency-free port against the real kernel — exact agreement on familyOf/tissueOf across all 256 tool names, innervate across 5 commands, evalCondition across 27 combinations, and attributeFailure across 8 error strings. When no kernel build is present, parity skips loudly rather than passing quietly.

Runtime state is observable too — vitals, wounds, synapses and the pulse stream are all first‑class data:

body_status      → organs · capabilities claimed · heartbeat #31 @15s · heal rate 100%
body_heal        → 21 wounds healed · 0 chronic
body_pulse       → last nerve impulses, reflex fires, homeostasis alerts

Repository layout

agent-body/
├─ packages/
│  ├─ organ-core/   zero-dependency organ core: constant tables, gating, contract, host adapter
│  └─ organ-sdk/    defineOrgan() / defineReflex() — the authoring surface
├─ benchmarks/      reproducible token benchmark + frozen corpus + CI baseline
├─ catalog/         organs.json — tiers, permissions, failure handling (generated, drift-checked)
├─ examples/        the five-minute quickstart demo
├─ docs/            organ SDK guide · host adapter guide
├─ workspace/
│  └─ plugins/      the organs — one plugin per organ, each with src/ + lib/ + an offline regression
├─ scripts/         verify-repo.mjs · run-organ-regressions.mjs · run-tests.mjs
├─ .github/         CI (repo-check on Windows + Linux) and issue templates
├─ ARCHITECTURE.md  full system architecture
├─ ROADMAP.md       what the next six months are for
└─ README.zh-CN.md  中文文档

Runtime state (vitals, synapses, memory cards, pulse stream) lives in your harness data home, never in this repository.

Roadmap

• Publish the organ contract as a standalone SDK so third‑party plugins can declare organs in a few lines
• One‑command organ installer that links, builds and registers every organ against a given host checkout
• Cross‑body sync: export learned synapses / reflexes / skills and import them into another install
• Sleep‑time model training: let consolidation propose new reflexes for review instead of authoring them directly
• Web panel for the anatomy: live organ map, wound ledger, pulse stream

Notes

• Licensing. MIT for this project's own work (LICENSE). Plugins ported from upstream projects and the host itself keep their own terms — see THIRD_PARTY_NOTICES.md.
• Local‑first. The harness GUI binds 127.0.0.1 — it can read files and execute commands on the machine it runs on. Do not expose it to a network or put it behind a public reverse proxy.
• Windows‑first. Developed and measured on Windows 11 · Node 24 · PowerShell 7. Several organs ship Windows‑specific hardening (hidden‑window spawning, ACL sandbox compatibility). Linux/macOS paths exist but are less exercised.
• Numbers here are measured, not aspirational. Figures marked measured were read from a live install; runtime counts (organs, capabilities) are yours to reproduce with body_status.