How PD Relates to Adjacent Categories

Different tools solve different problems. This page is not a ranking — each category below solves its own problem well. It shows where each one fits, and where PD fits.

Principles Disciple is an AI Agent Governance System. Technically, it is an Agent Governance Runtime: it captures behavioral evidence, evolves owner-approved principles, and applies them through multiple governance channels.

PD & AI Memory

Memory: stores information — "What happened?" PD: governs behavior — "What should change because of what happened?"

Memory systems store and retrieve information: transcripts, preferences, facts. PD turns validated behavioral experience into owner-approved principles that change how the agent acts next time. The two complement each other; session memory remains the host's job.

PD & Prompt Engineering

Prompt: provides instructions — before execution. PD: governs behavioral improvement — after execution.

Prompt engineering provides instructions before execution. PD focuses on transforming experience after execution into reusable governance principles — then applying them through multiple governance channels, not only through text. Both shape behavior; they operate at different moments and at different layers.

PD & Agent Skills

Skills: provide capabilities. PD: governs how capabilities should be used.

Skills extend what an agent can do — new tools, new abilities. PD governs how the agent behaves while doing the work, under owner authority. The two compose naturally: skills add capability, PD aligns behavior.

PD & Guardrails

Guardrails: prevent unwanted actions. PD: helps define desired behavior patterns.

Guardrails mainly prevent unwanted actions — fences around what must not happen. PD works on the positive side: it turns validated experience into owner-approved principles that describe how the agent should behave, with review and reversibility built in. Guardrails answer "what is forbidden?"; PD answers "what should become habit?".

PD & Rule Engines

Rule engines: predefined conditions trigger predefined actions. PD: experience becomes principles; principles govern future behavior.

A rule engine executes mappings written in advance: when condition X matches, action Y fires. Nothing in that loop learns. PD works upstream of any rule: it turns real behavioral experience into owner-approved principles — and where a bottom line must be enforced, those principles can be hardened into executable rules through review, shadow testing, and explicit approval. Rules are how some principles get enforced; they are not where PD starts.

PD & Agent Runtimes / Harnesses

Runtimes & harnesses (Claude Code, Codex, OpenClaw, …): make the agent run. PD: makes the agent's behavior governable — on top of the runner you already have.

Runtimes and harnesses execute tasks, call tools, and orchestrate the loop. PD does none of that: it installs into these hosts as a governance layer and works through their extension points — observing behavior, distilling owner-approved principles, and applying them via prompt hooks and tool-call hooks. Choosing a runtime and choosing governance are two different decisions; PD assumes you have already made the first one.

PD & Autonomous Self-Improvement

Self-improving agents: decide changes themselves. PD: the Owner decides; the system proposes.

In PD, every principle proposal passes owner review before activation, and every activation is reversible. Improvement is experience-based; governance stays with the Owner.

One-line summary

Memory stores, prompts instruct, skills extend, guardrails fence, rule engines execute fixed mappings. PD governs behavioral improvement — turning repeated corrections into owner-approved, reviewable, reversible principles applied through multiple governance channels.

See also the FAQ.