# Bound – A deterministic control harness for AI agents

> Source: <https://github.com/Danny-de-bree/bound>
> Published: 2026-07-18 12:59:02+00:00

**Agents that know when good enough is enough.**

**The deterministic control harness for AI agents.**

Coding agents are good at continuing. They are less good at knowing when to stop.

BOUND sits between execution and the agent's next decision, turning observable evidence into a deterministic control signal:

**ACCEPT · RETRY · REPLAN · ROLLBACK**

- Download
.`BOUND-agent-skill.zip`

- In ChatGPT, open
**Profile → Skills → Create → Upload from your computer**. - Select the ZIP, review the scan result, and install the skill.
- Start a new chat and invoke it with
`@BOUND`

, or let ChatGPT select it when your request matches the skill description.

The Skills menu must be available for your ChatGPT account or workspace. Personal Skills may need to be installed separately in ChatGPT on the web and in the desktop app because those installations do not automatically sync.

BOUND includes an open `SKILL.md`

skill for Codex, Claude Code, Cline, Kilo
Code, and other compatible coding agents:

```
npx skills add Danny-de-bree/bound --skill bound
```

To install only for Codex without interactive selection:

```
npx skills add Danny-de-bree/bound --skill bound --agent codex -y
```

The skill lives in [ skills/bound/](/Danny-de-bree/bound/blob/main/skills/bound) and teaches the agent to
install BOUND, establish meaningful evaluation boundaries, collect real
evidence, report the numeric A/I/R/C/S/T calculation, and react to

`ACCEPT / RETRY / REPLAN / ROLLBACK`

.Choose your agent, open its integration prompt, and paste it into a new session:

**That's it.**

The prompt tells the agent to install BOUND, inspect its workflow, identify meaningful evaluation boundaries, and wire the harness into its control loop.

For the initial setup, use your agent's strongest **architecture or planning mode** — or a stronger model if available. This first pass should focus on defining the plan, meaningful step boundaries, acceptance criteria, risks, budgets, and observable evidence.

```
Paste integration prompt into agent
              ↓
Agent installs BOUND
              ↓
Agent inspects project + workflow
              ↓
Agent defines goals, contracts, and evidence
              ↓
You review the integration plan
              ↓
Agent wires BOUND into the workflow
              ↓
Run your agent with BOUND
```

Once configured, the normal execution loop can use BOUND deterministically. No LLM judge is required for observable criteria.

BOUND belongs after a meaningful execution step and before the agent decides whether to keep optimizing the same objective.

```
Agent executes
      ↓
Observable evidence
      ↓
BOUND evaluates
      ↓
ACCEPT / RETRY / REPLAN / ROLLBACK
      ↓
Agent changes its next action
```

Conceptually:

```
result = workflow.evaluate_step(
    contract=contract,
    evidence=evidence,
    criteria=criteria,
)

match result.decision:
    case "ACCEPT":
        continue_to_next_step()
    case "RETRY":
        retry_current_approach()
    case "REPLAN":
        choose_new_strategy()
    case "ROLLBACK":
        rollback()
```

The agent still owns planning, reasoning, tool use, code changes, and execution.

**BOUND decides whether the current result is good enough to move on.**

| Decision | Meaning |
|---|---|
ACCEPT |
Good enough. Stop optimizing this step and continue. |
RETRY |
Keep the current approach and make one focused correction. |
REPLAN |
Stop iterating on the current strategy and choose another approach. |
ROLLBACK |
A hard risk boundary was exceeded. Return to a safe state. |

BOUND can use observable evidence such as tests, lint and type checks, acceptance checks, expected changes, retries, tool calls, token usage, runtime, and rollback availability.

Good enough is enough. Keep progressing.

Without an explicit stopping policy, an agent can continue working after the task is already satisfactory:

```
task solved
    ↓
tests pass
    ↓
more refinement
    ↓
more calls and changes
    ↓
possible regression
```

BOUND adds an explicit control point:

```
task solved
    ↓
evidence collected
    ↓
BOUND evaluates
    ↓
ACCEPT
    ↓
continue to the next goal
```

BOUND does not replace the agent. It is a thin control harness around the agent's execution loop.

BOUND is the **control harness**.

Under the hood:

```
Contracts + evidence  → evaluation layer
BoundPolicy           → deterministic decision engine
BOUND                 → control harness
Integration prompts   → adoption layer
```

The scoring model, evidence mapping, thresholds, weights, calculations, and exact decision rules live in the technical documentation:

[Read the architecture and scoring model →](/Danny-de-bree/bound/blob/main/architecture/README.md)

If you want to integrate BOUND directly:

```
pip install bound-policy
```

Or:

```
uv add bound-policy
```

The PyPI distribution is `bound-policy`

; the Python import and CLI are `bound`

.

BOUND is experimental.

The scoring heuristics, weights, thresholds, and integration patterns still need broader validation on real agent workloads.

The next milestone is dogfooding BOUND inside real coding agents and measuring whether it reduces unnecessary post-solution work, calls, tokens, retries, and regressions without reducing task success.

```
git clone https://github.com/Danny-de-bree/bound.git
cd bound

uv sync
uv run pytest
uv run ruff check .
```

MIT © Danny de Bree