Bound – A deterministic control harness for AI agents
BOUND is a lightweight control harness that adds a deterministic evaluation step after each agent action, using observable evidence to decide whether to ACCEPT, RETRY, REPLAN, or ROLLBACK, preventing unnecessary refinement and regressions.
Notifications You must be signed in to change notification settings
Fork 0
Star 1
BranchesTags
Open more actions menu
Folders and files
NameName
Last commit message
Last commit date
Latest commit
History
24 Commits
24 Commits
.github/workflows
.github/workflows
architecture
architecture
assets
assets
benchmarks
benchmarks
bound_integration
bound_integration
docs
docs
examples
examples
integrations
integrations
scripts
scripts
skills/bound
skills/bound
src/bound
src/bound
tests
tests
.gitignore
.gitignore
.pre-commit-config.yaml
.pre-commit-config.yaml
CHANGELOG.md
CHANGELOG.md
CONTRIBUTING.md
CONTRIBUTING.md
LICENSE
LICENSE
Makefile
Makefile
README.md
README.md
pyproject.toml
pyproject.toml
uv.lock
uv.lock
Repository files navigation
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
Put BOUND in your agent
Install in ChatGPT / OpenAI Skills
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.
Install with skills.sh-compatible agents
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/ 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.
Or use a paste-ready integration prompt
Choose your agent, open its integration prompt, and paste it into a new session:
Cline
Claude Code
Kilo Code
Hermes Agent
Any other agent
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.
The control loop
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.
Four decisions
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.
Why BOUND?
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.
How it works
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 →
Manual installation
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.
Current status
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.
Development
git clone https://github.com/Danny-de-bree/bound.git cd bound
uv sync uv run pytest uv run ruff check .
License
MIT © Danny de Bree
About
A deterministic control harness for AI agents. Know when to accept, retry, replan, or roll back.
pypi.org/project/bound-policy/
Topics
agents
harness-framework
llm-agents
agentic-coding
Resources
Readme
License
MIT license
Contributing
Contributing
Uh oh!
There was an error while loading. Please reload this page.
Activity
Stars
1 star
Watchers
0 watching
Forks
0 forks
Report repository
Releases 1
BOUND v0.6.0
Latest
Jul 17, 2026
Packages 0
Uh oh!
There was an error while loading. Please reload this page.
Contributors
Uh oh!
There was an error while loading. Please reload this page.
Languages
Python 99.7%
Makefile 0.3%