# What Is the Continual Harness and How Does the /refine Command Improve Session State in Prime Agent?

> Discover the Continual Harness in Prime Agent, a persistent datastore for RLM kernel. Learn how the /refine command enhances session state with evidence-backed updates.

- Repository: [Prime Intellect/prime-agent](https://github.com/PrimeIntellect-ai/prime-agent)
- Tags: deep-dive
- Published: 2026-08-09

---

**The Continual Harness is a persistent, lightweight datastore that lives alongside the Recursive Language Model (RLM) kernel to record supplemental prompts, memories, and skills, while the `/refine` command enables the agent to iteratively improve this session state through evidence-backed updates without modifying the immutable base system prompt.**

The `PrimeIntellect-ai/prime-agent` repository introduces a novel approach to persistent agent memory through the Continual Harness architecture. This system allows Prime Agent to accumulate reusable knowledge across conversation turns and survive agent restarts without bloating the base system prompt. Unlike traditional approaches that modify core instructions, the Continual Harness maintains a separate, mutable datastore that works in conjunction with the RLM kernel.

## Understanding the Continual Harness Architecture

### Core Components and RLM Integration

The Continual Harness operates as a persistent datastore alongside the **Recursive Language Model (RLM)** kernel. According to the implementation in [`prime-agent-runtime/src/rlm/harness.py`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/prime-agent-runtime/src/rlm/harness.py), it records **supplemental prompts**, **memories**, **skill definitions**, and **reusable sub-agent specifications**. Each entry represents a small, self-contained piece of knowledge that the agent can manipulate through CRUD operations without touching the immutable base system prompt defined in [`packages/coding-agent/src/core/prompts/rlm.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/coding-agent/src/core/prompts/rlm.ts).

### Persistent Storage and Concurrency Safety

The harness state is stored on disk as [`harness_state.json`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/harness_state.json), making it resilient against agent restarts. The implementation includes concurrency safeguards through `HarnessState._sync_from_disk()`, which reloads the state if another process rewrites the file. This prevents stale snapshots from overwriting the latest changes when concurrent edits occur, such as simultaneous host `/refine` requests.

## How the /refine Command Improves Session State

### The Refinement Workflow

The `/refine` command serves as the agent-exposed mechanism for improving the session's harness state. When invoked via `await refine.run()` (documented in [`packages/coding-agent/skills/refine/SKILL.md`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/coding-agent/skills/refine/SKILL.md)) or the host `/refine` command, the model executes a three-stage process:

1. **Diagnose** the failure and determine which harness component (memory, skill, prompt note, or sub-agent spec) requires modification.
2. **Apply focused updates** using CRUD methods on the harness such as `create_memory`, `update_skill`, or `delete_prompt_note`.
3. **Record the change** as a `RefinementEvent` to maintain a concise history of "what was changed and why" for future inspection.

### Evidence-Backed State Mutations

Unlike prompt rewriting approaches, `/refine` applies **evidence-backed updates** to specific harness components. The command does not rewrite the base system prompt; instead, it only mutates supplemental harness entries. This leaves the core agent behavior unchanged while allowing the session to accumulate reusable knowledge. When the `global_` flag is used, these refinements persist across agent restarts.

## Implementing Harness Operations in Practice

The following examples demonstrate how to interact with the Continual Harness programmatically using the methods defined in [`prime-agent-runtime/src/rlm/harness.py`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/prime-agent-runtime/src/rlm/harness.py):

```python

# 1️⃣ Create a memory about a recurring tip

await rlm.harness.create_memory(
    title="Git status reminder",
    content="Always run `git status` before committing.",
    id="git_status_tip"
)

# 2️⃣ Update a skill after discovering a better pattern

await rlm.harness.update_skill(
    id="my_skill",
    title="Optimized data fetch",
    content="Use asyncio.gather for parallel I/O.",
    reference={"type": "python", "import": "my_pkg.fetch", "callable": "fetch_all"},
)

# 3️⃣ Record the refinement that led to the update

await rlm.harness.record_refinement(
    trigger="observed repeated I/O slowdown",
    changes=["updated skill `my_skill` to use asyncio.gather"],
    evidence="timing logs from three runs",
    outcome="speedup ≈ 2×"
)

# 4️⃣ Inspect the current harness overview

print(await rlm.harness.overview())

```

## Key Implementation Files

According to the Prime Agent source code, the Continual Harness and `/refine` functionality are implemented across several critical files:

- **[`prime-agent-runtime/src/rlm/harness.py`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/prime-agent-runtime/src/rlm/harness.py)**: Contains the core `HarnessState` class, CRUD methods (`create_memory`, `update_skill`, `delete_prompt_note`), and `record_refinement` implementation.
- **[`packages/coding-agent/src/core/prompts/rlm.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/coding-agent/src/core/prompts/rlm.ts)**: Defines the system prompt snippet that informs the model about the Continual Harness and proper `/refine` usage.
- **[`packages/coding-agent/skills/refine/SKILL.md`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/coding-agent/skills/refine/SKILL.md)**: Provides user-facing documentation for the `await refine.run()` skill interface.
- **[`packages/coding-agent/test/system-prompt.test.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/coding-agent/test/system-prompt.test.ts)**: Validates that the system prompt correctly contains the Harness state section and refine guidance, ensuring the model understands how to utilize these capabilities.

## Summary

- The **Continual Harness** is a persistent datastore that maintains supplemental knowledge separate from the base system prompt, stored in [`harness_state.json`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/harness_state.json).
- The **`/refine` command** enables iterative improvement of harness state through `await refine.run()`, applying targeted updates to memories, skills, and prompts without modifying core agent behavior.
- **Concurrency safety** is ensured via `HarnessState._sync_from_disk()`, preventing data loss during simultaneous access.
- **Traceability** is maintained through `RefinementEvent` records, which document the trigger, changes, evidence, and outcome of each refinement operation.
- Changes can persist across **agent restarts** when using the `global_` flag, enabling long-term knowledge accumulation.

## Frequently Asked Questions

### What is the difference between the Continual Harness and the base system prompt?

The Continual Harness maintains mutable supplemental entries (memories, skills, sub-agent specs) in [`harness_state.json`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/harness_state.json), while the base system prompt remains immutable. The harness allows dynamic updates through the `/refine` command without altering the core agent instructions defined in [`packages/coding-agent/src/core/prompts/rlm.ts`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/packages/coding-agent/src/core/prompts/rlm.ts).

### How does the /refine command prevent data loss during concurrent operations?

The `/refine` command leverages `HarnessState._sync_from_disk()` to reload the state from disk before applying changes. If another process (such as a host `/refine` request) modifies [`harness_state.json`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/harness_state.json) simultaneously, the guard detects the discrepancy and refreshes the local snapshot, preventing stale overwrites.

### Can refinements made via /refine persist after the agent restarts?

Yes, when refinements are created with the `global_` flag, they persist across agent restarts because the Continual Harness stores all entries in the persistent [`harness_state.json`](https://github.com/PrimeIntellect-ai/prime-agent/blob/main/harness_state.json) file on disk, rather than maintaining state only in memory.

### What types of components can be modified using the /refine command?

The `/refine` command can modify four primary harness components: **memories** (via `create_memory`), **skills** (via `update_skill`), **prompt notes** (via `delete_prompt_note` or similar CRUD methods), and **sub-agent specifications**, all without affecting the immutable base system prompt.