Most conversations about AI Agents focus on competing over model parameters and inference capabilities, but anyone who has shipped a product knows: the infrastructure layer that makes model outputs production-stable is the most grueling part to build.

This project extracts that infrastructure layer into a unified, pluggable layer, shrinking months of development work down to a single line of config.

### Let's Clarify Basic Concepts First

The project splits an AI Agent into two clear components:

- **Model**: The large language model we all know, responsible for generating content. You only need to rent it and call it via an API key.

- **Harness**: Responsible for enabling model outputs to run reliably in real-world systems, and includes six core components:

1. Context: Provides the information the model needs to make decisions

2. Tools: APIs, functions and capabilities the model can invoke

3. Permissions: Defines the scope of actions the model is allowed to access and execute

4. Sandboxes: Isolated environments for the model to safely run code and modify files

5. Sessions: Maintains conversation state to keep context consistent across multi-turn dialogue

6. Artifacts: Stores final outputs generated by the model, including code, reports, spreadsheets, and more

So the formula is simple: **Agent = Harness + Model**.

### Why Not Build It From Scratch Yourself?

Today's leading harnesses including OpenAI Codex, Anthropic Claude Code, DeepSeek Harness and Hermes all have their own interface specifications, runtime logic, and permission systems. If you want your product to support multiple harnesses, or switch between different harnesses later, you have to build custom adapters for each one, rewriting everything from frontend to backend. This takes one to two months at minimum, and up to half a year.

After that you still have to maintain it: every time a harness updates, you have to update your adapter layer too. It never ends.

HarnessRouter's approach is to wrap all leading harnesses with a single unified interface. You only integrate the API once, and you get access to every supported harness. Switching between them just requires changing one line of configuration.

Your original custom architecture is: `Frontend + Backend + Custom-built Harness (rewrite all six components from scratch)`

After adopting HarnessRouter it becomes: `Frontend + Backend + Unified Integration Layer (choose from Codex/Claude/DeepSeek)`


### Core Features of the Open Source Community Edition

This is a fully runnable local version, with these key features:

1. **Your data, your keys, your bill**: All information is stored in your own Docker volume. API keys are only sent to the corresponding model provider and never leave your infrastructure. There are no cloud accounts and no telemetry data collection.

2. **True isolated sandboxes**: The Agent for each session runs under a separate dedicated system user. Files and data from different sessions are completely isolated: one Agent cannot read or write content from another session, and cannot access your product's sensitive information. This is low-level permission isolation, not just a verbal restriction.

3. **OpenAI Responses API compatible**: If you already have code integrated with OpenAI, you can adopt this with almost no changes. The UHP protocol only adds extension fields required for harness functionality on top of the existing API, and leaves your original logic untouched.

4. **Supports all major model providers**: You can connect to Anthropic, OpenAI, OpenRouter, Azure Foundry, and Bedrock, and you can add your own OpenAI-compatible endpoints.

### 6-Step Local Deployment

You only need Docker, ~4GB of disk space, and an API key from a model provider. No account registration required:

1. Pull the image

```bash

docker pull harnessrouter/harnessrouter

```

The download size is around 700MB.

2. Run the container

```bash

docker run -d --name harnessrouter \

-p 127.0.0.1:3000:3000 \

-v harnessrouter:/data \

harnessrouter/harnessrouter

```

No placeholder values required. You can add your API key and password later in the console. Do not add the `--user` parameter: the container needs to start as root to create dedicated session users, and will drop privileges automatically after startup.

3. Wait for installation to complete

Don't open your browser right away. The first launch needs to install the CLI for each harness, which takes roughly 30 seconds. Check the logs to wait for it to be ready:

```bash

docker logs -f harnessrouter

```

Once you see the output `ready on :3000` you can proceed to the next step.


4. Log in and change your password

Open `http://localhost:3000`, the default username and password are both `harnessrouter`. After logging in, the first thing to do is change your password via the Profile menu in the top right corner.

5. Connect your model provider

Open the Integrations page, click Add Integration, select your provider, and paste your API key. The service automatically maintains the list of supported models for you, no manual configuration required.


6. Start using it

Go to Tasks -> New Task, select your harness on the left, pick a model, enter your request, and run it. During the entire execution, every command run by the Agent and every file modified is streamed back to you in real time. You'll get the final result at the end, and can download a full archive of all outputs.


### Ready-To-Use Starter Kits

The project ships with several working, ready-to-use starter applications, these are full runnable apps, not just code snippets:

- **Slides**: You just describe what topic you want your presentation to cover, and the Agent will automatically plan the structure and build it slide by slide. All elements are editable, and you can change your requirements at any point during building.


- **Sheets**: You provide the data structure, and the Agent will process the table row by row, automatically filling in results. It can handle 1000 rows, and you can stop and modify requirements at any time. The example below is the result of automatically searching for and compiling a list of Silicon Valley investors.


- **Dashboards**: Enter your requirements, point to your database, and the Agent will automatically read the table schema, write queries, select appropriate charts, and generate an interactive dashboard. It re-runs queries every time you open it to show the latest data: all numbers are pulled live, not static screenshots.


- **Videos**: Describe the video you want, and the Agent will automatically storyboard, render, and stitch clips together to output a full downloadable video. Note that every shot requires generation, which incurs model costs, so we recommend trying this only after you are familiar with the system.

### The Open Unified Harness Protocol

More than just a tool, the project also released the open, standardized Unified Harness Protocol (UHP). The current version is dated 2026-08-11, and includes 10 specification chapters that define everything from architecture and lifecycle to error handling, plus a full conformance test suite. Anyone can implement this protocol, no dependency on HarnessRouter cloud services required.

The protocol is intentionally designed to be compatible with the OpenAI Responses API to reduce integration cost, so existing clients can adopt it with major rewrites.

The project team has openly addressed several key concerns raised in community discussions:

- Tool-level permission controls across different harnesses are not yet unified. Claude and Pi support hard blocking, while other harnesses currently rely on instructions to the model. This issue has been added to the protocol roadmap, and will be unified into standardized primitives in the future. For now you can stick with Claude or Pi if you require hard guarantees.

- DeepSeek Harness itself does not currently have a complete permission and sandbox layer, which is not an issue with the protocol. This will be fixed on the build side in future updates.

- Switching harnesses does not change the outer sandbox boundary for file system and network access. This part is already unified, and permission rules are never changed silently.

### Who Is This Project For?

If you are building a product with Agent capabilities, don't want to spend months building harness infrastructure, and want to quickly test different leading Agent solutions, this project fits your needs perfectly.

If you only use Agents personally for local work, existing tools like Claude Code and Codex are already sufficient, and you don't need an extra abstraction layer.

Project repository: [https://github.com/HarnessRouter/harnessrouter](https://github.com/HarnessRouter/harnessrouter)

Protocol website: [https://unifiedharnessprotocol.org](https://unifiedharnessprotocol.org)

Licensed under Apache 2.0, fully open source and usable for commercial purposes.