openhuman: an open-source agent harness with a Rust core

~/openhuman❯openhuman status --live

❯ openhuman trade --with fees ● floor live

what happens when OpenHuman trades the fees?

one of the most powerful open-source agents gets a coin's creator fees as its bankroll and trades them on chain. every decision public, every trade a transaction. the floor is live: its scouts are already trading.

▶ launch trading floor

❯ an open-source agent harness with a Rust core. lightweight, modular, pluggable into whatever LLM, memory or search engine you already run.

one core runs the desktop app, the browser UI, the terminal client and a Rust library. agents share a process instead of one daemon each, so 500 live agents settle at 1,393 MiB, about 25× denser than 500 separate processes. jev decides without generating prose. workflows are drafted by the agent and reviewed by you on a canvas. GPL-3.0.

102 ms cold agent turn, 476 ms nine-phase bootstrap, 42 MiB slim RSS, 1,770 KiB marginal per agent at 500, 51 MiB stripped binary with nothing enabled.

$REPOgithub.com/tinyhumansai/openhuman

❯ one TinyHumans API key covers inference, web search, embeddings, media, voice and the jev ranker. pass it once — .api_key("th_…") in code or OPENHUMAN_BACKEND_API_KEY for a headless host — and every service is live. ~ bring your own: 26 BYOK providers, Ollama, LM Studio, MLX

▶ launch trading floor download ↗ cargo add openhuman-embed docs ↗

❯ manual how it works · discord · x · reddit

●openhuman desktop · demo.pngopen ↗

❯ tail -f origin/main.log30 recent commits

main❯reading commits…

❯ top one process, every surfaceworkspace v0.64.12

1[|||||||||||||||···········]7 crates, 8 modules

2[|||||||||·················]9 gates, contrib default

Mem[||||||||||················]15.2 MiB heap / 42 MiB RSS

Bin[|||||||||||||||||||||||||·]51 slim · 60 lib · 116 full MiB

Tasks: 7 crates, 8 native modules, 9 feature gates; 1 process

Fleet: 500 agents settled at 1,393 MiB, 3 ms idle CPU per 10 s

Surfaces: desktop (Tauri v2 + Wry) · browser SPA · terminal (ratatui) · library

PIDNAMESKINDGATE / BUSDESCRIPTION

S: R running in-process · L loadable native module · descriptions from each crate's Cargo.toml and the README

❯ fleet sweep 50 / 100 / 500 agents, one processperformance.md ↗

N agents	marginal KiB	settled MiB	threads	FDs
50	1,985	223	71	420	[\|\|··········]
100	1,866	356	123	820	[\|\|\|·········]
500	1,770	1,393	211	3,220	[\|\|\|\|\|\|\|\|\|\|\|\|]
500 × process	~48 MiB each	~24,000	—	—	25×

cold agent turn

102ms

47.6 MiB median RSS

nine-phase bootstrap

476ms

paid once per process

warm turn

0.5–1.9MiB

vs 26–31 MiB first turn

slim process

42MiB

15.2 MiB private heap

mock inference at 200 ms latency so idle time behaves like real traffic. reproduce: ./scripts/profile/library-fleet.sh --agents "50,100,500"

~/openhuman❯openhuman fleet --sweep 50,100,500# one process, many agents. measured, not claimed.

density why in-process beats one daemon per agent

500agents

live in one process, settled at 1,393 MiB total

1,770KiB

marginal cost per additional agent at N = 500

~48MiB

per instance when the same workload runs as separate processes, flat across N

25× denser

thousands of agents on one box is the direction, not a number hit yet

fixed base: one process per agent pays the ~30–50 MiB base every time. one process for all agents pays it once.
idle CPU: 3 ms per 10 s at every N. idle agents cost memory, not cycles.
threads: 71 → 123 → 211 across 50 → 100 → 500 agents. sub-linear.
file descr.: 420 → 820 → 3,220. about 6.4 per agent, the one line that scales linearly.
compression: tinyjuice cuts what reaches the model, so a large context costs less than its raw size suggests.

cold path what a process pays once

scenario	median RSS	median time
agent-turn cold, one turn, no delegation	47.6 MiB	102 ms
cold-phases config load, registry init, agent build, memory construction, first turn	51.2 MiB	476 ms
warmed turn same process	+0.5–1.9 MiB	vs +26–31 MiB first

binary cargo feature gates control what compiles in

build	features	unstripped	stripped
pure slim	none	68.4 MiB	51.0 MiB
library-minimal	skills, flows	~81.1 MiB	~60.4 MiB
default	all nine gates	115.9 MiB	n/a

scripts/kernel-floor.sh keeps a down-only ratchet on the dependency count so the floor doesn't creep back up. sources: library-benchmarking.md, harness-comparison-2026-07-22.md.

~/openhuman❯openhuman core --status# releases, gates, modules, jev. the parts of the kernel.

releases github.com/tinyhumansai/openhuman/releases—

tag	date	assets

jev tool search, 215 core tools + 1,000 Composio actions, 160 requests

1bm25 top-122.5% · 28 ms p50
2embed+jev top-162.0% · 1.5 s p50
3embed+jev top-366.7%
4app-first composio80.3% top-1
5needless callsbm25 26/31 → jev 1/31

jev is a small decision model run through the TinyHumans System One proxy: a question plus a fixed set of options in, a calibrated probability per option out. Choice, Score, or yes/no (Noul). it never writes prose. consequential browser actions (a purchase, a send, a delete) return NeedsConfirmation instead of executing. falls back to BM25 with no credential.

feature gates contributor default, nine

native modules loadable past compile time, each with a *-bus contract crate

tinydocs: documents · tinydocs-bus
tinyvoice: voice · tinyvoice-bus
tinyjuice: token compression · tinyjuice-bus
tinyruntime: runtime · tinyruntime-bus
tinywallet: wallet · tinywallet-bus
tinymcp: MCP servers · tinymcp-bus · 0.4.0 on main
tinychannels: messaging channels · tinychannels-bus
tinyconnectors: app connectors · tinyconnectors-bus

workflows tinyflows engine, open source

node kinds: 22 — agent calls, HTTP, code, conditions, loops, sub-workflows, approvals, more
triggers: schedule · app event · manual; resumes mid-run after a pause
difference: you describe it, the agent drafts the graph, you review and save on a canvas. not n8n wiring by hand.

contributors top 30 by commits—

~/openhuman❯openhuman engines --list# every engine is chosen by config, not hardcoded.

LLM

managed: the TinyHumans route, with the OpenRouter model catalogue
local: Ollama · LM Studio · MLX · any OpenAI-compatible server
agent sdk: Claude Code or the Claude Agent SDK
byok: 26 providers: OpenRouter, OpenAI, Anthropic, Google, Groq, Mistral, DeepSeek, Together, Fireworks, …

embeddings

managed: Voyage-backed route
your own: Voyage · OpenAI · Cohere · Ollama · OpenAI-compatible endpoint

memory v2: Recall, Fetch, Store

engine: hosted CortexDB via TinyHumans, or your own CortexDB (endpoint + key). with neither, memory is off.
brain: folders, files, links, GitHub, RSS, connected apps; each agent's conversations and shared learnings
per turn: recalls what matters before every turn; answers with citations
sync: scheduled sync of folders, repos, feeds and apps into memory

web search

managed: included with a subscription
your key: Parallel · Brave · Querit · Exa · Tavily · self-hosted SearXNG

OAuth integrations

100+

connected apps

MCP servers

5k+

via tinymcp

skills

90k+

loadable

messaging channels

15

incl. native email (IMAP/SMTP)

meetings: joins Meet, Zoom, Teams and Webex, speaks, keeps a live transcript. orchestration: agent graphs, checkpoints, E2E-encrypted A2A. from the harness comparison in the README.

~/openhuman❯cargo add openhuman-embed# one Runtime per process, any number of Agents on it.

crates/openhuman-embed/README.mdsource ↗

use openhuman_embed::{Access, AgentSpec, McpServer, Provider, Runtime, Workspace};

let runtime = Runtime::builder()
    .workspace(Workspace::dir("/var/lib/my-product/openhuman"))
    .api_key("th_live_…")                     // the only credential in library mode
    .build()
    .await?;

let reviewer = runtime.agent(
    AgentSpec::new("reviewer")
        .system_prompt("You review pull requests and never edit files.")
        .access(Access::readonly())
        .skills_dir("./skills/review")        // copied into this agent's own skills root
        .action_dir("/srv/checkouts/pr-42"),
)?;

let fixer = runtime.agent(
    AgentSpec::new("fixer")
        .provider(Provider::openai_compatible("https://api.example/v1", "sk-…").model("gpt-5"))
        .access(Access::full())
        .mcp(McpServer::stdio("github", "gh-mcp", ["stdio"]))
        .action_dir("/srv/checkouts/pr-42"),
)?;

let review = reviewer.run("Summarise the risks in this change.").await?;
let fix = fixer
    .turn(format!("Address these findings:\n{}", review.reply))
    .send()
    .await?;
println!("{}", fix.reply);

// Continue a conversation with the same agent.
let again = fixer.turn("Now run the tests.").session(&fix.session_id).send().await?;
println!("{}", again.reply);

what each agent owns

provider: its own LLM route: managed, local, or any OpenAI-compatible URL + key
access: readonly() or full(): the tier the agent runs at
action_dir: the working directory it may act on
skills_dir: copied into the agent's own skills root
mcp: its own MCP servers, e.g. a stdio github server
prompt: system prompt, sandbox, session continuation via .session(id)

the one key

in code: .api_key("th_…")
headless: OPENHUMAN_BACKEND_API_KEY
covers: managed inference (incl. OpenRouter catalogue), web search, embeddings, media generation, integrations, voice, jev

surfaces on the same core

desktop: Tauri v2 + Wry — Windows, macOS, Linux
browser: the identical SPA: pnpm dev:app:web
terminal: ratatui client: crates/openhuman-tui
library: openhuman-embed, feature-flag pass-through, minimal-footprint recipe in library-minimal-recipe.md

~/openhuman❯openhuman install# native packages first. scripts are unverified.

recommended native installer surfaces

macOS

brew install --cask openhumanHomebrew cask, normal signing and integrity checks

debian

sudo apt-get install -y --no-install-recommends ./OpenHuman_*_amd64.debdownload the release .deb first; arm64 on arm64 hosts. apt resolves runtime deps, avoids the AppImage Wayland / libgbm failures

arch

yay -S openhuman-binAUR recipe lives in packages/arch/openhuman-bin

windows

OpenHuman_<version>_x64_en-US.msisigned .msi from the latest release, run it

manual

.dmg · .deb · .AppImage · .msistraight from the latest release page

● script install no integrity check

mac / linux

curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash

powershell

irm https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.ps1 | iexserved live from raw.githubusercontent.com with no separate signature. the repo itself says: prefer the native paths above.

latest release assets —releases ↗

from source

web app

pnpm dev:app:webthe identical SPA in any browser

library

cargo add openhuman-embedlibrary-minimal recipe: skills + flows, ~60 MiB stripped

profile

./scripts/profile/library-fleet.sh --agents "50,100,500" --target 1000 --budget-mib 2048reproduces the fleet sweep

~/openhuman❯man openhuman

OPENHUMAN(1)OpenHuman ManualOPENHUMAN(1)

NAME

openhuman — an open-source agent harness with a Rust core: lightweight, modular, pluggable.

SYNOPSIS

openhuman [config] → agents → jev → tools → workflows → memory

DESCRIPTION

core: a Rust core with a desktop app, a browser UI, a terminal client and a library wrapped around it. the same core runs all four, in-process, not as a daemon the UI talks to over a socket.
fleet: 50, 100 and 500 live agents in one process cost 1,985, 1,866 and 1,770 KiB marginal each, settling at 223, 356 and 1,393 MiB. as separate processes the same work costs ~48 MiB per instance.
modular: nine cargo feature gates by default; eight loadable native modules past compile time, each with a *-bus contract crate.
engines: LLM, embeddings, memory and web search are all chosen by config. managed TinyHumans routes, or your own.
jev: a small decision model that returns calibrated probabilities over fixed options. it never writes prose. 62.0% top-1 tool pick vs 22.5% for BM25; one needless call vs 26.
workflows: saved, typed automation graphs on the tinyflows engine, 22 node kinds. the agent proposes, you review on a canvas and save.

LICENSE

GPL-3.0. early beta: under active development, expect rough edges. within one week of launch it was the number one trending repository on GitHub for nine days in a row.

COMPARISON

	Cowork	OpenClaw	Hermes	OpenHuman
open source	proprietary	MIT	MIT	GPL
start	desktop+CLI	terminal	terminal	UI, minutes
memory	chat-scoped	plugin	self-learning	pluggable, cited
integrations	few	BYO	BYO	100+ OAuth, 5k+ MCP, 90k+ skills
workflows	none	scripts	scripts	visual, gated
meetings	none	none	none	Meet/Zoom/Teams
channels	none	a few	a few	15

from the README; products evolve, verify against each vendor.

EXAMPLES

# install the desktop app on macOS
$ brew install --cask openhuman

# run the identical SPA in a browser
$ pnpm dev:app:web

# embed the core in your own Rust process
$ cargo add openhuman-embed

# reproduce the fleet sweep
$ ./scripts/profile/library-fleet.sh --agents "50,100,500"

NAME

SYNOPSIS

DESCRIPTION

LICENSE

COMPARISON

EXAMPLES

SEE ALSO