tinyhumansai · senamakel · Aug 27, 2026 · Aug 26, 2026 · Aug 26, 2026 · Aug 26, 2026
diff --git a/README.md b/README.md
@@ -41,6 +41,12 @@ Not ready to sign in? `medulla --mock` runs a full offline demo, with no account
 
 Prebuilt binaries ship for Linux (x86_64, aarch64), macOS (Apple Silicon), and Windows (x86_64). Building from source, pinning a version, and embedding the SDK are covered in [Getting Started](https://tinyhumans.gitbook.io/medulla/developers/getting-started).
 
+## No tmux, no multi-agent wrapper
+
+Running a lot of agents has meant one of two workarounds: split the terminal into panes and be the scheduler yourself, or wrap the harnesses in another agent and hope it can read everything they produce. Medulla is one process, in one terminal, built for the job instead.
+
+Opening another agent is `Ctrl-T` — pick a harness or a shell, pick a directory, it is running. There is no ceiling on how many you keep open. Each gets its own terminal, kept live in the background whether or not it is the one on screen, and Medulla reads all of them for the things that need a human: a permission prompt, a blocking error, a dead session, a turn finished and waiting on review. Those arrive as `⚠ 3 waiting on you`, not as three panes you were supposed to have been watching.
+
 ## What you get
 
 Your whole fleet, legible. One lane per agent, live. You can see what each agent is doing, answer the one that has a question, and cancel the one that has gone wrong, without losing your place in everything else.

diff --git a/docs/TERMINOLOGY.md b/docs/TERMINOLOGY.md
@@ -46,6 +46,8 @@ that CLI:
 | Codex          | ACP over stdio                                                  |
 | `codex-server` | JSON-RPC over stdio to a shared, long-lived `codex app-server`  |
 | OpenCode       | ACP over stdio                                                  |
+| OpenHuman      | In-process: no binary spawned, no transport. The wire value is `HarnessProvider::Openhuman`; the agent turn runs inside the `medulla` process on the vendored `tinyagents` crate with Medulla's own tools (`src/sdk/src/daemon/providers/local/mod.rs`). Never auto-selected by provider detection — a node reaches it only by naming it. |
+| Shell          | None: a plain interactive shell (`bash`, `zsh`, whatever `$SHELL` names), not a coding agent. Never detected as an available provider and never dispatchable; it exists so an operator can open a terminal beside their agents in the same pane, host, and working directory. |
 
 `codex-server` is a **flavor** of Codex rather than a separate harness type: it
 authenticates, bills, and configures as Codex and differs only in that one
@@ -97,6 +99,13 @@ wants work done, the **hub** delivers a `TaskRequest` (carrying a `task_id`,
 **worker** and collects the `TaskOutcome`. It is the outbound half of the
 daemon's task loop.
 
+The hub also carries the **workflow plane** (`src/sdk/src/hub/plane/`): the wire
+contract with the Medulla orchestration backend for saved workflow graphs —
+Socket.IO shapes and `medulla:*` event names (`payloads.rs`) — and the
+store-side `WorkflowBridge` trait (`bridge.rs`) an embedding host installs to
+answer them. It used to be re-exported from the embedded OpenHuman core; with
+that core removed, Medulla is the only host left that speaks it.
+
 ## Cycle
 
 One orchestrator turn: **user input → reasoning → tool calls → reply**. A cycle
@@ -220,10 +229,15 @@ with `medulla init` and registered with `medulla workspace add`.
 ## Provider
 
 A coding-assistant CLI: the same axis as an agent's **harness** type, seen from
-the process end. The three supported providers are `claude` (Claude Code),
+the process end. The three coding-CLI providers are `claude` (Claude Code),
 `codex` (OpenAI Codex), and `opencode`. The daemon spawns the CLI as a subprocess
 and communicates over ACP or legacy JSONL.
 
+Two more providers sit outside that coding-CLI set: `openhuman`, the in-process
+harness that runs an agent turn inside the `medulla` process instead of
+spawning one (see **Harness** above), and `shell`, a plain interactive shell
+that is never dispatchable or auto-detected.
+
 A provider is chosen together with a **transport**, and the pair is named by one
 word, a **flavor**. `codex` is Codex on its CLI; `codex-server` is the same
 provider on a shared `codex app-server` process. Anything that follows from

diff --git a/docs/attribution-proxy.md b/docs/attribution-proxy.md
@@ -88,14 +88,17 @@ All three spawned harnesses are covered. OpenCode is accepted as a
 `customHarnesses` base even though it can reach OpenRouter natively, because that
 native path is exactly the one this proxy needs to take over.
 
-The embedded OpenHuman core is covered too, by a different mechanism. It is not a
-child process, so there is no environment to inject into and nothing to scrub:
-Medulla resolves the preset's key, exchanges it for a loopback token, and hands
-the core the mount and the token as a *per-call* route on
-`inference_agent_chat`. The core applies that route to the turn's own in-memory
-configuration and never persists it, so borrowing an endpoint for one node does
-not repoint the account's own inference. As with a spawned harness, the core is
-given the token and never the OpenRouter key.
+The local in-process harness is covered too, by the same mechanism through a
+different call shape. Naming `openhuman` as a node's harness no longer dispatches
+into a separate core; it runs the turn in-process on the vendored `tinyagents`
+loop, with Medulla's own tools. That turn is not a child process, so there is no
+environment to inject into and nothing to scrub: Medulla resolves the preset's
+key, exchanges it for a loopback token, and hands the turn the mount and the
+token directly as the route it calls inference on. Unlike a spawned harness, this
+one has no ambient inference configuration to fall back to — with no router
+preset naming an endpoint and a model, the turn refuses to run rather than
+resolving one some other way. As with a spawned harness, the turn is given the
+token and never the OpenRouter key.
 
 One limitation applies. Medulla injects environment variables at the spawn seam
 and never writes a harness's own configuration file. A harness you have

diff --git a/docs/e2e-live-harness.md b/docs/e2e-live-harness.md
@@ -11,8 +11,8 @@ One end-to-end round trip over the **host link** (`docs/host-link-protocol.md`),
 with no real keys and no network egress:
 
 ```
-owner driver (examples/coordination_owner.rs; a real medulla-link endpoint)
-  → mock link forwarder (examples/mock_link_forwarder.rs; blind UDP, §5)
+owner driver (src/sdk/examples/coordination_owner/main.rs; a real medulla-link endpoint)
+  → mock link forwarder (src/sdk/examples/mock_link_forwarder.rs; blind UDP, §5)
     → medulla daemon (real binary, `--providers <harness>`, the host end)
       → the real coding CLI (spawned by the daemon as its provider)
         → mock LLM (e2e/coordination/mock_llm.py)
@@ -57,8 +57,8 @@ routed at the mock and which wire dialect it lands on.
 | `e2e/coordination/Dockerfile` | the harness image: a rust build stage layered onto that base |
 | `e2e/coordination/build-image.sh` | build (and optionally push) either image |
 | `e2e/coordination/run-docker.sh` | build + run the whole harness in a container |
-| `examples/mock_link_forwarder.rs` | blind UDP forwarder implementing protocol §5 rules 1-8 |
-| `examples/coordination_owner.rs` | owner-side driver: enrolls pairs, serves legs, prints terminal frame JSON |
+| `src/sdk/examples/mock_link_forwarder.rs` | blind UDP forwarder implementing protocol §5 rules 1-8 |
+| `src/sdk/examples/coordination_owner/main.rs` | owner-side driver: enrolls pairs, serves legs, prints terminal frame JSON |
 
 ## Running
 

diff --git a/docs/plans/harness-workflow-skills.md b/docs/plans/harness-workflow-skills.md
@@ -26,7 +26,7 @@ Facts this plan rests on, each checked against the tree at `11351b34`:
 - **Declared inputs are already on the listing view.** `WorkflowSummary.inputs`
   (`src/sdk/src/workflows/types/workflow.rs:176`) carries `Vec<WorkflowInput>` —
   `name`, `type`, `description`, `required`, `default`
-  (`vendor/openhuman/vendor/tinyflows/src/model/inputs.rs:112`). Rendering a skill needs
+  (`vendor/tinyflows/src/model/inputs.rs:112`). Rendering a skill needs
   only `workflow_list`, not a graph fetch.
 - **Tool-surface gating already exists.** `ToolMode::{Full,Propose}` +
   `MEDULLA_WORKFLOW_TOOLS` (`src/sdk/src/workflows/mcp/evolve.rs`) withhold verbs from

diff --git a/docs/vendoring.md b/docs/vendoring.md
@@ -1,110 +1,77 @@
 # Vendored dependencies
 
-Some upstream crates are consumed as git submodules under `vendor/` rather than
-from crates.io. The workspace `exclude = ["vendor"]` keeps them out of `members`,
-so they carry their own lints and tests instead of joining this repository's CI
-gates.
+Three upstream crates are consumed as git submodules under `vendor/` rather than
+from crates.io. The workspace `exclude = ["vendor", "worktrees"]` keeps them out
+of `members`, so they carry their own lints and tests instead of joining this
+repository's CI gates.
 
 | Submodule | Upstream | Consumed as |
 | --- | --- | --- |
-| `vendor/tinyplace` | `tinyhumansai/tiny.place` | path dependency |
-| `vendor/tinycortex` | `tinyhumansai/tinycortex` | path dependency |
-| `vendor/tinyflows` | `tinyhumansai/tinyflows` | registry coordinate + `[patch.crates-io]` |
+| `vendor/tinyagents` | `tinyhumansai/tinyagents` | registry coordinate `2.1` + `[patch.crates-io]` |
+| `vendor/tinyflows` | `tinyhumansai/tinyflows` | registry coordinate `0.8` + `[patch.crates-io]` |
+| `vendor/tinyhumans-sdk` | `tinyhumansai/sdk` | path dependency (no registry coordinate) |
 
-Initialize everything with:
+Initialize with:
 
 ```sh
-git submodule update --init --recursive
+bash scripts/init-submodules.sh
 ```
 
-## tinyflows
+not `git submodule update --init --recursive`. `vendor/tinyagents` carries a
+`wiki` documentation submodule that nothing here compiles, and `--recursive`
+descends unconditionally. The script is also the one place the vendored set is
+written down, and must stay in lockstep with the root manifest's
+`[patch.crates-io]` table.
 
-`tinyflows` is the DAG workflow engine behind the `workflows` feature. It is
-declared in the root `Cargo.toml` as a *registry* dependency and redirected to
-the submodule:
+All three submodules are self-contained: none declares a path or git dependency
+of its own, and none carries code submodules of its own. `.gitmodules` uses
+HTTPS URLs so CI clones them without a deploy key.
 
-```toml
-[workspace.dependencies]
-tinyflows = { version = "0.5", features = ["mock"] }
+## What each one is for
+
+`tinyagents` is the agent harness — the bounded model/tool loop that
+`src/sdk/src/daemon/providers/local/` runs in-process for the `openhuman`
+harness provider, replacing what used to be an `inference_agent_chat` RPC into
+the embedded core. The `sqlite` feature brings `tinyagents::session`, the durable
+store behind `src/sdk/src/agent/history/`; `tools` brings the builtin tool family
+the loop dispatches. Neither is on by default in the crate.
+
+`tinyflows` is the DAG workflow engine behind the SDK's `workflows` feature, reached
+through the adapter seam in `src/sdk/src/flow_engine/`. Its `mock` feature is a
+normal dependency feature rather than a dev-only one: the authoring surface
+dry-runs graphs against the engine's deterministic capability stand-ins in
+ordinary builds, not just in tests. `host-caps` and `store` supply the host
+capability set and the graph store.
+
+`tinyhumans-sdk` is the shared TinyHumans HTTP transport (`TinyHumansClient`)
+that `src/sdk/src/client/` builds the typed Medulla surface on: auth, durable
+sessions, SSE event streaming, one-shot orchestration, and the public feedback
+board. It owns credential headers, the `{success, data}` envelope, and path
+percent-encoding.
+
+## One declaration style per crate
+
+Declare each vendored crate exactly one way: either as a direct path dependency
+or as a registry coordinate redirected by the patch table, never both. Mixing the
+two yields two `PackageId`s for one crate and an `E0308` where the types look
+identical, the first time a value crosses the seam. `tinyhumans-sdk` is a path
+dependency because it has no registry coordinate to patch.
+
+`[patch.crates-io]` applies only from the workspace root:
 
+```toml
 [patch.crates-io]
-tinyflows = { path = "vendor/tinyflows" }
+tinyagents = { path = "vendor/tinyagents" }
+tinyflows  = { path = "vendor/tinyflows" }
 ```
 
-This is the same shape the sibling `openhuman` host uses. The indirection exists
-because crates.io lags the branch we track (the published maximum is `0.3.0`
-while the pinned tree reports `0.5.1`), so a plain registry dependency would not
-resolve to the code we build against. Keeping the registry coordinate (rather
-than a bare path dependency) means the two hosts share one pin and one upgrade
-cadence.
-
-**Pinned commit:** `fb24363aea921f957958bc8f4aeb5b0a244e41c7` (`v0.3.0-37-gfb24363`),
-matching `openhuman`.
-
-The `mock` feature is a normal dependency feature, not a dev-only one: the
-authoring surface dry-runs graphs against the engine's deterministic capability
-stand-ins in ordinary builds, not just in tests.
-
-### One `tinyagents`, and the patch entry is mandatory
-
-The graph must resolve exactly one `tinyagents`, and it must come from the
-vendored tree. OpenHuman's `vendor/tinycortex` requires `tinyagents = "2.1"`, so
-sourcing `tinycortex` from there collapses the graph to a single `tinyagents`,
-and the root `[patch.crates-io]` entry for `tinyagents` is **mandatory**.
-Omitting it does not fail loudly: `tinyagents 2.1.0` is published on crates.io,
-so the build silently resolves the registry copy instead of the vendored tree
-(~14 commits ahead).
-
-Verify with `cargo tree -i tinyagents`: the source must read `path+file://…`,
-never `registry+…`. `cargo tree -d` must report no duplicate `tiny*`.
-
-## Vendored OpenHuman core
-
-`vendor/openhuman` carries the OpenHuman core that medulla embeds. Several rules
-about it are load-bearing and easy to get wrong.
-
-Initialize it with `scripts/init-submodules.sh`, never with `--recursive`.
-`vendor/openhuman` has submodules of its own, two of which belong to the
-OpenHuman *desktop* app, including a Tauri fork that bundles CEF. `--recursive`
-clones both, and nothing in medulla's graph references either (the Cargo
-workspace excludes `vendor/`, so `app/src-tauri` is not a member). A git
-dependency would not help: Cargo updates git-dependency submodules recursively
-with no opt-out, which makes the CEF clone mandatory. The submodule plus an
-explicit init list is the only way to avoid it.
-
-The root `[patch.crates-io]` table is load-bearing. `[patch.crates-io]`
-applies only from the workspace root, so once OpenHuman is a path dependency
-*its* patch table is ignored, as is
-`vendor/openhuman/vendor/tinycortex/.cargo/config.toml`, which is CWD-scoped.
-This workspace's root manifest must therefore reproduce OpenHuman's entire table
-with paths rewritten to `vendor/openhuman/vendor/*`. Drop an entry and Cargo
-quietly resolves the published crate instead of the vendored tree.
+Dropping an entry does not fail loudly. Both crates are published, so Cargo
+silently resolves the registry copy instead of the vendored tree.
 
-Declare each vendored crate exactly one way: either as a direct path dependency
-or as a registry coordinate redirected by the patch table, and never both for the
-same crate. Mixing the two styles yields two `PackageId`s for one crate and an
-`E0308` where the types look identical, the first time a value crosses the
-medulla↔OpenHuman seam. Guard with `cargo tree -d`, which must report no
-duplicate `tiny*`.
-
-When the two repos disagree on a shared pin, the newer pin wins and the bump
-lands in OpenHuman. Adopting an older OpenHuman pin wholesale is a hard compile
-break (for example, a `tinyplace` ancestor missing `signal::maintain`, which
-`src/sdk/src/daemon/transport/mod.rs` calls), so advance the pin *in OpenHuman*
-and let this gitlink follow rather than patching around it here.
-
-OpenHuman must never depend on the `medulla` crate. Its default-ON
-`medulla-local` feature currently has an empty dependency list. The day someone
-gives it a real edge, `medulla-public → openhuman → medulla` becomes a Cargo
-dependency cycle and a hard failure.
-
-Coverage excludes the vendored tree. `vendor/` path deps are *local*
-packages under the workspace root, so `cargo-llvm-cov`'s default registry filter
-does not drop them; the gate's `--ignore-filename-regex` starts with
-`(^|/)vendor/` for that reason. Removing it sinks the 95% gate to roughly the
-first-party share of a very large tree.
+Verify with `cargo tree -i tinyagents` — the source must read `path+file://…`,
+never `registry+…` — and `cargo tree -d`, which must report no duplicate `tiny*`.
 
-### Updating the pin
+## Updating a pin
 
 ```sh
 cd vendor/tinyflows
@@ -115,7 +82,27 @@ cargo build            # confirm the adapter seam still compiles
 cargo test
 ```
 
-Then update the pinned commit recorded above and commit the gitlink. Because
-`tinyflows` is pre-1.0 and still changing its `engine` entry points, expect the
-adapter seam in `src/sdk/src/tinyflows/` to need attention on an update; the rest
-of the SDK should not.
+Then commit the gitlink. Because `tinyflows` is pre-1.0 and still changing its
+`engine` entry points, expect `src/sdk/src/flow_engine/` to need attention on an
+update; the rest of the SDK should not.
+
+## Coverage
+
+Coverage excludes the vendored tree. `vendor/` path dependencies are local
+packages under the workspace root, so `cargo-llvm-cov`'s default registry filter
+does not drop them; the gate's `--ignore-filename-regex` starts with
+`(^|/)vendor/` for that reason.
+
+## History
+
+Until v0.11.0 the runtime was an embedded OpenHuman core vendored at
+`vendor/openhuman`. It carried sixteen submodules of its own — two belonging to
+the OpenHuman desktop app, including a Tauri fork bundling CEF — and because
+`[patch.crates-io]` applies only from the workspace root, this manifest had to
+reproduce that core's entire patch table rebased onto `vendor/openhuman/vendor/*`:
+ten entries, eight of them pinning a crate nothing here linked directly, each one
+silently resolving to a published crate if dropped. `scripts/init-submodules.sh`
+had to enumerate the same set by hand because Cargo reported one missing entry
+per resolution failure, costing a CI round trip each. Removing the core removed
+that whole class of failure; what is left is the three self-contained crates
+above.