OpenHuman - Open Source Personal AI Agent

OpenHuman has grown into something more specific than “personal AI agent.” Its own summary: “The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.” It is “a desktop app for people. A Rust library for developers,” at version 0.64.15, carrying an early beta status badge.

Then it does something almost nothing in this category does: it publishes the benchmark that would embarrass it.

The benchmark it did not have to publish

OpenHuman maintains a public benchmarks repository with its methodology documented. We read the results for its swe-x86-1 suite — ten software-engineering tasks, deepseek/deepseek-v4.1-flash at high reasoning, 4 vCPU and 8 GB per task — comparing itself against six other harnesses.

The first row is the one most projects would have omitted:

metric	openhuman	claude-code	codex	opencode	hermes
resolved	7/10	10/10	7/10	10/10	10/10
peak process RAM	68 MB	231 MB	123 MB	1.06 GB	816 MB
CPU time / solved task	1.31 s	4.68 s	3.28 s	17.2 s	16.1 s
task wall p50	19.8 s	37.8 s	36.1 s	28.4 s	58.5 s
tokens / solved task	166.6k	427.5k	369.7k	390.2k	481.7k
cost / solved task	$0.0077	$0.04	$0.02	$0.0077	$0.0082
static prompt (system + tools)	4,591	12.0k	7,665	6,729	13.2k

OpenHuman solved seven of ten tasks where four competitors solved all ten. It marks its own result red in its own table.

And then it wins almost everything else, decisively. 68 MB of peak process memory against 231 MB for the nearest comparable and over a gigabyte for two others. A third of the CPU time. Half the wall-clock. Under 40% of the tokens per solved task. That 68 MB figure is also the mechanical explanation for the headline claim — at that footprint, hundreds of concurrent agents on a cheap VPS is arithmetic rather than marketing.

The project’s own caveat is appropriately careful, and we will repeat it rather than paper over it: “Small samples: treat differences as indicative, not a ranking.” Ten tasks is ten tasks, and these are the project’s own measurements of its own competitors.

But the shape of the result is the useful finding. “Fastest, cheapest, most efficient” is substantiated. “Best” is not claimed, and the published data shows exactly where the gap is. A project that prints a competitor’s better number beside its own has earned more trust than one that publishes a single bar chart — the same instinct we noted in agentmemory, which also publishes a table where a rival wins the headline metric.

Note also that Hermes appears in that comparison, with 816 MB peak RAM and 16.1 s of CPU per solved task against OpenHuman’s 68 MB and 1.31 s. Efficiency is a real axis of difference between these tools, and until someone published numbers it was invisible.

The licence is the catch, and it is a big one

The README’s own comparison table lists competitors as Apache-2.0 and MIT, and itself as GPL-3.0. Cargo.toml is more precise:

license = "GPL-3.0-only"

GPL-3.0-only. Not “or-later,” and with no commercial-licence offer, linking exception or dual-licensing note anywhere in the repository.

Now read that against the second half of the pitch. OpenHuman ships EMBED.md and an openhuman-embed crate, which “runs the OpenHuman core inside your Rust program,” where “your host owns the user interface, server transport and authentication flow” and the core “owns agent turns, memory, tools, approvals and execution policy.” It is a genuinely well-documented embedding story, with typed facades for runtime, agents, channels, cron, memory, MCP, skills and observability.

Linking a GPL-3.0-only library into your Rust program makes your program subject to the GPL. There is no exception on offer.

For a personal project, an internal tool, or anything you are happy to publish, that is fine — arguably better than fine, since copyleft is a deliberate choice and the project is upfront about it. For a company planning to embed this core in a proprietary product, it is a blocking consideration, and it is precisely the case EMBED.md is written to serve. Resolve the licence question before you write the integration, not after.

Two details worth stealing

The embedding documentation contains two design decisions that are good regardless of whether you use OpenHuman.

Access is a context, not a level. The docs describe Access as grouping “permission level, origin, standing grants and trusted roots,” with the instruction to “choose an origin and tier together: a trusted local host request and an external channel message are different security contexts.” That is the right model. Most agent frameworks have one permission setting and no notion that a message from a chat channel deserves less trust than a local call.

Multi-tenancy is explicit, with a stated footgun. Ordinary runtime agents “share an operator’s configuration path and credentials,” and the docs say flatly that “two agents are not two authenticated customers.” Serving different users requires ProfileRuntime with provisioned profiles. Naming that trap in the documentation, rather than letting people discover it in production, is the mark of someone who has been asked the question.

A smaller one, from the skills documentation: bundle “discovery rejects symlinked bundles, so linking a shared directory does not install it.” Copying is intentional. That is a deliberate guard against a confusing class of configuration bug.

Who should look at it

Anyone running many agents, where resource cost is the binding constraint rather than peak capability — fleets, schedulers, background workers, cheap hardware. The efficiency numbers are the reason to care, and they are published.

It is the wrong choice today if you need the highest task-completion rate, which the project’s own benchmark shows it does not currently lead, or if you are building a closed-source product on top of the Rust core.

The finding: OpenHuman publishes a benchmark in which it resolves 7 of 10 tasks against competitors’ 10 of 10, while using 68 MB of peak memory to their 231 MB–1.06 GB and a third of the CPU. That is a credible efficiency story told honestly. The thing to check before building on it is license = "GPL-3.0-only", which sits awkwardly beside a first-class embedding API and has no stated exception.