OpenHarness: an open agent harness from HKUDS with a personal agent called ohmo

The gap OpenHarness fills between a model and a working agent

A model on its own cannot read a file, run a test or open a pull request. OpenHarness is the layer that supplies what the README calls hands, eyes, memory and safety boundaries. It is a Python implementation aimed at researchers, builders and the community: people who want to understand how a production agent loop behaves, experiment with tool and skill patterns, and extend the harness with their own plugins and providers.

The second half of the project is ohmo, a personal agent built on top of the harness. The pitch is narrow and specific. You talk to ohmo inside Feishu, Slack, Telegram or Discord, and it forks branches, writes code, runs tests and opens pull requests. The README states that ohmo runs on an existing Claude Code or Codex subscription, so no separate API key is required. That single constraint shapes who the project is for: someone already paying for one of those subscriptions, not someone shopping for a model provider.

Inside the harness: the agent loop, the toolkit and the memory files

The architecture splits into five areas the README lays out as cards. The agent loop handles streaming tool calls, retries the API with exponential backoff, executes tools in parallel, and counts tokens and cost. The toolkit is the largest surface: 43 tools covering file, shell, search, web and MCP operations, plus skills loaded on demand from .md files. Skills, hooks and agents form a plugin ecosystem that the README says is compatible with anthropics/skills and plugins.

Context and memory are file-based rather than opaque. The harness discovers and injects CLAUDE.md, compresses context automatically when it grows, keeps persistent memory in MEMORY.md, and supports session resume and history. Governance is the fourth area: multi-level permission modes, path-level and command rules, PreToolUse and PostToolUse hooks, and interactive approval dialogs. The fifth is multi-agent coordination through subagent spawning, a team registry, task management and background task lifecycle, with ClawTeam integration listed on the roadmap.

The data flow implied by these pieces is conventional for this class of tool: a session starts, CLAUDE.md and MEMORY.md are injected into the context, the model streams tool calls, hooks fire around each call, permissions gate what actually executes, and results feed back into the loop until the turn ends. What is less conventional is how much of that is exposed as files and hooks rather than hidden behind an SDK. That is the point of the project, and it is also the source of its rough edges.

Installing OpenHarness and running a first session

The package is published as openharness-ai and requires Python 3.10 or newer. The project defines four console entry points in pyproject.toml: openharness, oh, openh and ohmo, with oh described in the README as the one command to launch the harness. Installing the package looks like this:

pip install openharness-ai

After that, the oh command starts the terminal interface. The README's What's New section documents `oh --dry-run`, which previews resolved runtime settings, auth state, skills, commands, tools and configured MCP servers without executing the model, tools or subagents.

oh

For ohmo, the entry point is separate:

ohmo

The README states that ohmo connects to Feishu, Slack, Telegram or Discord and runs on your existing Claude Code or Codex subscription. The repository includes a frontend/ directory and a frontend/terminal package that is force-included into the wheel, which is where the React and Ink terminal interface lives. If you only want the harness library and not the TUI, the Python dependencies in pyproject.toml are the ones to read before installing: they include anthropic, openai, mcp, textual, typer and the four chat platform SDKs.

Permission modes and hooks are the real safety boundary

The governance card lists multi-level permission modes, path-level and command rules, and PreToolUse and PostToolUse hooks. This is the part of the harness worth reading before you let ohmo near a repository. An agent that forks branches and opens pull requests is executing shell commands and writing files on your behalf, and the only thing standing between a bad tool call and your working tree is the permission configuration.

The design choice here is that rules are declarative and hook-based rather than baked into each tool. That is flexible: you can write a PreToolUse hook that inspects a command before it runs, or a command rule that blocks a path entirely. It also means the safety of a deployment depends on how carefully those rules are written; v0.1.4 added built-in sensitive-path protection in PermissionChecker. Treat the permission layer as something you configure, not something you inherit.

Where OpenHarness is the wrong tool

The most concrete limitation is the stakes: ohmo forks branches, writes code and opens pull requests on its own, so read the permission settings and the docs/ directory before you rely on it.

There is also a maintenance question. The last push to the repository was on 2026-06-04, and the most recent release listed is v0.1.9 from 2026-05-07. The version number is still 0.1.x. That is not disqualifying for a research-oriented harness, but it does mean you should expect the plugin surface to move.

Finally, ohmo is the wrong tool if you do not already have a Claude Code or Codex subscription, or if your team's chat platform is not one of the four the README names. And if your goal is a stable, vendor-supported coding assistant with a documented support path, this is a research project, not that.

How OpenHarness differs from Claude Code and opencode

The pyproject.toml description calls OpenHarness an open-source Python port of Claude Code, so the comparison is built into the project's own framing. The practical difference is language and inspectability. Claude Code is a product you install and use; OpenHarness is a Python codebase you can read, fork and extend, with the agent loop, permission rules and hooks visible in source. If your reason for adopting a harness is to modify it, that difference is the whole argument.

Against opencode, the distinction is breadth versus focus. OpenHarness bundles a 43-tool toolkit, a skill loader compatible with anthropics/skills, persistent memory files, multi-agent coordination and a separate personal agent in ohmo. A leaner harness gives you fewer moving parts to reason about. The trade-off is real in both directions: more surface area means more to configure and more places for the plugin contract to be underspecified.

Licence and upgrade cost

OpenHarness is MIT licensed, and pyproject.toml declares license = "MIT" alongside the LICENSE file at the repository root. For most teams that means permissive use, modification and redistribution with attribution, but the licence text is the authority and this is not legal advice. Note that the project depends on anthropic, openai, mcp and four chat platform SDKs, each with its own licence, so a distribution that bundles them inherits those terms too.

Upgrade cost is shaped by the 0.1.x version line and the plugin surface. Skills are plain .md files, which are cheap to migrate. Hooks and agents are code. The release notes files in the repository root, RELEASE_NOTES_v0.1.8.md and RELEASE_NOTES_v0.1.9.md, are the place to check what changed between versions before you upgrade a working setup.

Editorial conclusion

Adopt OpenHarness if you want to read and modify the loop that drives an agent, or if you want ohmo answering in Feishu, Slack, Telegram or Discord without a separate API key. Skip it if you need a stable plugin contract, since the project is still at version 0.1.x. Before installing, confirm that Python 3.10 or newer is available and that you are willing to let ohmo fork branches and open pull requests under whatever permissions you grant it.

Frequently asked questions

Official sources

1. HKUDS/OpenHarness on GitHub
2. Issues
3. License: MIT
4. README
5. Releases