OpenHarness: Open Source Agent Harness with ohmo Personal AI Assistant

What OpenHarness Is and Who It Is For

An agent harness, as the README defines it, is the complete infrastructure that wraps around an LLM to make it a functional agent. The model provides intelligence; the harness provides "hands, eyes, memory, and safety boundaries." OpenHarness is an open source Python implementation of that infrastructure.

The project has two components. OpenHarness itself is the core framework: tool-use primitives, skills (on-demand loaded Markdown files), memory management, and multi-agent coordination. ohmo is a personal AI agent built on top of that framework, described in the README as "an assistant that actually works for you over long sessions" rather than a generic chatbot.

The README states the target audience as researchers who want to understand how production AI agents work, builders experimenting with agent coordination patterns, and developers extending the harness with custom plugins and providers. The `pyproject.toml` description calls it an "Open-source Python port of Claude Code," indicating its primary inspiration in design.

The package is named `openharness-ai` on PyPI and provides three command aliases: `oh`, `openh`, and `openharness`. The personal agent component installs as `ohmo`.

The Agent Loop: Tools, Retries, and Cost Tracking

The core of OpenHarness is its agent loop. The README documents four aspects of this loop: a streaming tool-call cycle, API retry with exponential backoff, parallel tool execution, and token counting with cost tracking.

The harness ships with 43 built-in tools covering file operations, shell execution, web search, web fetch, and MCP (Model Context Protocol) server connections. Skills are loaded on demand from Markdown files, matching the pattern where domain-specific instructions are injected into the agent context only when relevant. The plugin ecosystem supports custom skills, hooks that run before or after tool calls (PreToolUse and PostToolUse), and custom agents.

Parallel tool execution is listed as a supported feature in the loop. The exponential backoff on API retries handles transient provider errors without requiring manual intervention in long-running sessions.

Token counting and cost tracking are built into the loop rather than being external tooling. This is relevant for long autonomous sessions where a team needs to monitor API spend without running a separate cost dashboard.

OpenHarness supports multiple AI providers. The `pyproject.toml` dependencies include both the Anthropic SDK (`anthropic>=0.40.0`) and the OpenAI SDK (`openai>=1.0.0`). The v0.1.4 release notes mention native Moonshot/Kimi provider support with reasoning content for thinking models.

Memory, Context Compression, and Session Management

OpenHarness manages three layers of memory. CLAUDE.md files in a project directory are discovered and injected into the agent's context, carrying project-specific instructions. MEMORY.md provides persistent memory that survives session restarts. Session resume and history allow a session to be continued from a previous state.

Context compression is automatic. The README describes an Auto-Compact feature, first introduced in v0.1.6, that compresses context when it grows large while preserving task state and channel logs. The design goal, as stated in the release notes, is that agents can run multi-day sessions without manual compact or clear operations.

When running subagent teams, subprocess teammates run in headless worker mode. Their context is separate from the main agent's context, meaning team coordination does not inflate the primary agent's context window.

The `oh --dry-run` flag, listed as an unreleased feature in the README, previews resolved runtime settings, loaded skills, configured MCP servers, and auth state without executing the model or tools. It reports a `ready`, `warning`, or `blocked` verdict with specific remediation steps.

Governance: Permissions, Hooks, and Safety Boundaries

The harness includes a governance layer that controls which actions an agent can take. Multi-level permission modes, path-level rules, and command-level rules define the safety envelope. Interactive approval dialogs surface permission requests that fall outside the pre-configured rules.

PreToolUse and PostToolUse hooks execute code before or after a tool call, which is the extension point for teams that need audit logging, custom approval logic, or pre-processing of tool inputs. These hooks are part of the plugin ecosystem alongside skills.

The v0.1.4 release notes reference a built-in sensitive-path protection in the PermissionChecker and hardened URL validation in the `web_fetch` tool. Security concerns in earlier versions prompted the v0.1.4 security overhaul, and the v0.1.8 release title explicitly references "Safer Remotes" as a focus.

The `oh --dry-run` preview command is also a governance tool: it lets a team member review what an agent would load and which tools it would have access to before authorizing a run, without risk of the agent taking actions.

ohmo: Personal AI Agent for Chat Platforms

ohmo is a separate component that runs on top of the OpenHarness infrastructure. The README describes it as able to fork branches, write code, run tests, and open pull requests autonomously in response to chat messages.

ohmo connects to four platforms: Feishu (via the `lark-oapi` SDK), Slack (via `slack-sdk`), Telegram (via `python-telegram-bot`), and Discord (via `discord.py`). All four are listed as runtime dependencies in `pyproject.toml`. This means a single ohmo instance can be deployed to receive instructions from any of these chat platforms without requiring separate deployments.

The README states that ohmo runs on an existing Claude Code or Codex subscription with no extra API key needed, though the exact mechanism for this is not documented further in the README.

The v0.1.6 release added channel slash commands and multimodal attachment support. The v0.1.8 release added Feishu group support. The v0.1.9 release updated provider key handling. The `ohmo` CLI entry point installs alongside the `oh` command from the same `openharness-ai` package.

Installing and Running OpenHarness

The package installs from PyPI as `openharness-ai`. Python 3.10 or later is required, per the `requires-python` constraint in `pyproject.toml`. The hatchling build backend is used:

pip install openharness-ai

This installs both the `oh` command for OpenHarness and the `ohmo` command for the personal agent. The v0.1.7 release notes document that the install script places these commands in `~/.local/bin` to avoid conflicts with Conda-managed shell environments.

The React-based terminal frontend is bundled inside the wheel (from `frontend/terminal/` as documented in `pyproject.toml`'s `force-include` section). A Textual-based TUI is also available as an alternative to the React TUI.

The current release is v0.1.9. The last push to the repository was on 2026-06-04. Development slowed after May 2026 relative to the April 2026 pace, but the project is not archived.

OpenHarness vs Claude Code: Extensibility vs Managed Integration

Claude Code is Anthropic's proprietary CLI for Claude, documented as the official interface for Claude in terminal and coding workflows. Claude Code is closed-source and targets the Anthropic Claude API specifically. OpenHarness is open source and supports Anthropic, OpenAI, and Moonshot/Kimi as providers, meaning teams can switch or combine providers without re-implementing the agent infrastructure.

The design trade-off is control versus stability. OpenHarness exposes the full harness for modification: the tool list, the permission system, the hook points, and the memory management are all available as extension surfaces. This matters for researchers who want to study agent behavior or builders who need to customize how the agent interacts with their specific tooling.

Claude Code provides a managed experience with Anthropic's support and is the target platform that ohmo explicitly states it runs on. Teams that need a coding assistant that works without configuration and whose behavior is consistent across updates will find the managed option simpler. Teams that need to audit, modify, or extend the agent's behavior at every layer will find OpenHarness's open source approach more practical.

Editorial conclusion

OpenHarness fits researchers and developers who want to inspect, modify, and extend the infrastructure of an LLM coding agent without being locked to a single provider. The ohmo component adds practical value for engineering teams that communicate through Feishu, Slack, Telegram, or Discord and want an agent that can take autonomous coding actions in that context. Teams looking for a stable, production-supported coding agent CLI without modification should evaluate Claude Code or other managed options. Before installing, verify Python 3.10 or later and check the v0.1.9 release notes to confirm which providers are supported with the current authentication mechanism.

Frequently asked questions

Official sources

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