Skip to main content
PraisonAI implements three pillars of agentic reliability engineering — Context, Harness, and Loop (CHL). This page defines each principle, maps it to concrete modules and CLI commands, and specifies a measurable rubric with pass thresholds so teams can validate “framework compliance” consistently and gate releases on quantitative CHL scores.
CHL is a validation lens, not a new subsystem. Each principle already exists in code (context/, compaction/, runtime harness, eval/loop.py). This page unifies them under one rubric and links to the evaluators that score them.

​
1. Principles

​
1.1 Context Engineering

Context Engineering governs what the model sees on every turn: keeping token usage within budget, compacting history without losing meaning, injecting the right artifacts, and handing off cleanly between agents.
Sub-principleMeaningCode anchor
BudgetTotal prompt tokens stay within a configured budgetcontext/ (token budgeter), eval/tokens.py
CompactionHistory is compressed with high semantic retentioncompaction/ (6 strategies)
InjectionRelevant files/artifacts are added deterministicallycontext/ (artifacts, fast context)
HandoffContext transfers between agents without lossagent/ handoff, ContextAgent PRP
Terminology aligns with the ContextAgent PRP methodology and Context Management. CHL does not redefine those concepts — it scores them.

​
1.2 Harness Engineering

Harness Engineering guarantees that the environment the agent runs in during testing matches production: identical tool schemas, reproducible turn context, and required trace/artifact outputs.
Sub-principleMeaningCode anchor
ParityPreparedTurnContext tool schemas match runtime exactlyruntime/turn_context.py
TracesEach turn emits a structured, replayable tracetrace/, harness runner
ArtifactsRequired output files are present after a runinteractive test harness / CSV runner

​
1.3 Loop Engineering

Loop Engineering makes autonomous iteration converge safely: reaching a quality threshold in a bounded number of iterations while doom-loop guards prevent unproductive repetition.
Sub-principleMeaningCode anchor
ConvergenceIterations reach the target score within a boundeval/loop.py (EvaluationLoop)
GuardrailsDoom-loop / repeat guards fire on stagnationagent/autonomy.py, loop guards
EfficiencyFewest iterations for a given quality targeteval/loop.py iteration metrics

​
2. Measurable rubric

Each row maps a principle to a metric, a pass threshold, and the evaluator that produces the score. Targets are defaults — override per project via config.
PrincipleMetricTargetEvaluator
Context handoffhandoff score 0–10≥ 8.0ContextEvaluator
Context budgettokens ≤ budget100% complianceContextEvaluator
Compaction losssemantic retention (judge score)≥ 7.0ContextEvaluator
Harness paritytool schema hash match100%HarnessEvaluator
Harness artifactsrequired files present100%HarnessEvaluator
Loop convergenceiterations to threshold≤ N (configurable)LoopEvaluator
Doom-loop safetyguard fires on repeat fixturerequiredLoopEvaluator
The ContextEvaluator, HarnessEvaluator, and LoopEvaluator classes are tracked as follow-up work (PA-CHL-001–004). Until they land, the equivalent checks can be run with today’s building blocks: estimate_tokens / count_tokens (praisonaiagents.eval), the compaction judge, the interactive test harness, and EvaluationLoop.

​
Interpreting scores

Context

All three context rows must pass for a build to be “context-compliant”.

Harness

Parity is a hard gate — any schema drift fails the harness pillar.

Loop

Convergence + guard firing together certify safe autonomy.

​
3.1 CLI commands

# Context: budgeting and compaction
praisonai context            # inspect / manage context window
praisonai compaction         # run and inspect compaction strategies

# Harness: reproducible interactive testing
praisonai test interactive --suite smoke   # run a built-in harness suite
praisonai test interactive --list          # list available suites

# Loop: bounded autonomous iteration
praisonai loop               # run the evaluation / improvement loop

# Eval: run any evaluator (accuracy, safety, loop, ...)
praisonai eval

​
3.2 Python entry points

from praisonaiagents.eval import (
    EvaluationLoop,        # Loop convergence + efficiency
    estimate_tokens,       # Context budget checks
    count_tokens,
)
# Compaction judge and the interactive test harness cover the
# remaining Context and Harness rows until the dedicated
# ContextEvaluator / HarnessEvaluator / LoopEvaluator land.

Context Management

Token budgeting, compaction strategies, overflow prevention.

ContextAgent

PRP methodology and Context Engineering handoff.

Autonomy

Autonomous loops and doom-loop guardrails.

Evaluation

The evaluation framework these evaluators plug into.

​
4. Running a CHL eval suite

Once the dedicated evaluators land, a CHL suite runs like any other evaluation: 
from praisonaiagents.eval import EvalSuite

# Composes Context / Harness / Loop evaluators into one report,
# scored against the rubric thresholds in Section 2.
suite = EvalSuite(name="chl-compliance")
report = suite.run(print_summary=True)
Wire the resulting pass/fail into CI to gate releases on quantitative CHL scores.

​
5. Summary

PillarQuestion it answersRubric rows
ContextDoes the agent see the right, budgeted, well-compacted context?budget, compaction, handoff
HarnessDoes the test environment match production exactly?parity, artifacts
LoopDoes autonomy converge safely without doom loops?convergence, doom-loop safety
CHL turns scattered examples and code comments into a single, measurable definition of “framework compliance” that engineers can onboard against and CI can enforce.