Make consequential software decisions explicit before an agent implements them.
AgentDirective turns a plain-language project description into traceable safeguards, questions, requirements, tests, and evidence expectations—without allowing a model to become the source of policy.
How AgentDirective moves from ordinary project language to reproducible, versioned requirements while preserving the decisions that only a person can make.
The authoritative path
Deterministic signals and context rules identify candidate architecture characteristics. The user corrects them. A rule engine then selects Control Packs. Optional model output may suggest a characteristic only when local detection finds nothing; it cannot decide applicability or supply a business value.
Deterministic by defaultSame confirmed architecture and methodology version, same applicable pack set.
Explicit unknowns“Not decided” stays unresolved instead of becoming a guessed default.
Versioned outputDirectives record the methodology, pack, and schema versions that produced them.
1. Extract architecture characteristics
Characteristics describe capabilities and boundaries, not technologies alone. Examples include sensitive data, untrusted input, tool access, financial action, multiple tenants, production modification, and irreversible action.
A candidate retains its provenance
The reason and source travel with the characteristic. A rule-inferred candidate is not presented as something the user explicitly said.
user_stated — selected or written by the user
rule_inferred — matched by versioned rules
model_suggested — optional bounded suggestion
user_corrected — changed by the user
architecture-model.json
{
"id": "FINANCIAL_ACTION",
"value": true,
"confidence": 0.90,
"provenance": "rule_inferred",
"reason": "The proposal includes a payment action."
}
2. Match Control Packs
Every pack carries a machine-readable applies_when expression. The rule engine evaluates it against the confirmed architecture model and records why the pack matched.
Policy does not come from a model
The pack library determines applicability. A model cannot invent a pack, bypass its rule, or silently suppress one that matches.
If the architecture model changes, applicability is recomputed and the difference is recorded.
Applicable packs surface material questions. Quick Review prioritizes the few questions most likely to change implementation; Full Review exposes every applicable question.
StatusMeaningMay provide a binding value?
confirmedAn authorized person supplied the answer.Yes
recommendedA pack recommendation has not been accepted.No
unresolvedThe material question remains open.No
not_applicableThe user says the question does not apply and gives a rationale.No
explicitly_rejectedThe user consciously rejects the safeguard and gives a rationale.No
4. Compile, track, and review
Compile
Create the canonical directive first
agent-directive.json is the source of truth. Human-readable instructions and agent wrappers are derived from it.
Track
Keep requirement status repository-local
The coding agent updates one status entry per requirement and appends material changes to an event history.
Review
Compare claims with expected evidence
The bounded reviewer checks schema validity, completeness, evidence pointers, and contradictions without calling agent claims independent verification.
Reassess
Preserve history when scope changes
A new directive reports added, changed, unchanged, and retired requirements. Prior decisions are not rewritten invisibly.
5. Versioning and governance
Schemas, the methodology, the pack library, and individual packs use semantic versions. Applicability or requirement changes require a pack version change. Breaking data-contract changes require a schema major version.
Each pack is expected to carry technical review, evidence review, applicability fixtures, limitations, and changelog history before it can move from review to released. At present, every published pack remains in review.
Learn
Control Packs
A Control Pack is a versioned safeguard: when it applies, what can fail, what must be decided, what must be implemented, and what evidence should exist.
Pack anatomy
applies_whenApplicability
A deterministic condition over confirmed characteristics.
failure_modesFailure model
The concrete class of harm or breakdown the pack addresses.
questionsHuman decisions
Material values the system must not invent.
requirementsImplementation contract
Stable, testable statements with severity and references.
verificationExpected evidence
Tests, implementation pointers, telemetry, policies, or procedures.
control_mappingsExternal context
Carefully scoped relationships—not equivalence or certification.
Example: bounded autonomous action
AUT-001 applies when a system can perform a financial or consequential action. It does not choose the allowed amount. It asks the user, then compiles the answer into a requirement.
Question → requirement → evidence
The question supplies the missing boundary. The requirement defines the implementation. Verification expectations state what a later report should point to.
The example is shortened for readability. The canonical pack remains available through the pack library.
{
"pack_id": "AUT-001",
"question": "What limit applies before human approval?",
"requirement": {
"id": "AUT-001-R1",
"statement": "Enforce the confirmed action boundary, escalate outside it, make retries idempotent, and provide a disable path."
},
"evidence_expected": [
"configuration_or_policy",
"implementation_location",
"test_result",
"telemetry_definition"
]
}
Pack status
Draft
Initial content and fixtures are being developed.
→
Review
Published for use and evaluation, but not independently released.
→
Released
Technical and evidence reviews are complete.
→
Deprecated
Retained for history with a migration path.
Verification
See the methodology run.
Enter an ordinary build request and watch the public MCP detector identify characteristics, select Control Packs, ask for the decisions only a person can make, and compile those answers into agent-ready instructions.
What is being verified
These checks exercise observable methodology behavior. Every published pack has a versioned example that is run through the same deterministic detector and applicability engine used by the public MCP service.
01Selection
Does the example produce the architecture characteristics required by the pack’s published applicability rule?
02Questions
Does the matched pack surface its real material questions without supplying answers on the user’s behalf?
03Instructions
Do confirmed user answers become traceable requirements while unanswered decisions remain visibly unresolved?
Fixed-corpus stress test
25,000 wording variations, with the baseline preserved
Twenty user-background styles and thirty scenario archetypes were combined into 25,000 unique synthetic descriptions. The same corpus was rerun after each bounded detector change; expected labels and the seed were not rewritten to improve the score.
70.72% → 100%
Risk-bearing descriptions that reached at least one applicable Control Pack.
20.41% → 0%
Low-risk controls that incorrectly produced a characteristic or pack.
The first correction removed small team as a standalone multi-tenant signal. That initially lowered the risk-query score because the false positive had also been manufacturing packs for risk-bearing requests. Seven later bounded iterations addressed explicit export, file, tenant, webhook, cost, account, AI, vendor, and destructive-action wording. The stopping rule was reached when every risk-bearing case reached a pack and every low-risk control stayed clean.
A second 25,000-description corpus used 30 newly authored scenario families, 25 new user-background styles, new sentence structures, and a different seed. Automated checks found no exact request reuse and no full-query overlap with the development corpus. It was run once against signal dictionary 0.9.9, and the first result was preserved without tuning.
58.41%
Risk-bearing descriptions that reached at least one Control Pack.
28.49%
Expected-characteristic micro recall on the new language.
15.00%
Harmless controls that produced a false positive.
The result shows that the deterministic applicability rules are inspectable once characteristics are present, but the current phrase detector is too dependent on known vocabulary. Failures include missed multi-organization and export language, substring matching such as quota inside “quotation,” and insufficient negation handling for wording such as “no submissions.” Holdout v1 is now closed: improvements must be developed elsewhere and assessed on a fresh holdout.
The example below calls the public MCP endpoint. Change the request or start with the invoice example, then answer as many questions as you are prepared to decide.
Ready to analyze. No information has been sent yet.
1Request
2Detect
3Questions
4Directive
Observed characteristicsReturned by agentdirective_analyze
Matched Control PacksRule-based applicability, with the reason preserved
Final handoffCompiled by agentdirective_compile
Agent-ready requirements
Published verification cases
One inspectable example for every Control Pack
Each entry explains why the safeguard matters, when its rule applies, the question it asks, the instruction it contributes, and the test evidence it expects. “Run example” sends that exact request through the live MCP service.
Loading the 29 published verification cases…
AUT-003reviewv1.0.0Cost and Quota BoundaryMake expensive, high-volume, or quota-consuming automation bounded and observable.
Why this matters
A loop, batch, model, or provider call can exceed a budget, quota, or rate boundary without a safe stop or operator-visible warning.
Control objective
Define and enforce resource, cost, rate, and quota boundaries with safe degradation and operator visibility.
Questions for the user
What resource, rate, or cost limit must stop or escalate the operation?
Instructions generated for the agent
AUT-003-R1: Enforce confirmed resource and cost limits, bounded concurrency, safe degradation, and an operator-visible stop path.
Evidence-producing tests
RESOURCE_LIMIT_TEST: Exercise normal usage, threshold, exhaustion, concurrency, retry, and safe-stop behavior.
Verify a pack through MCP
Agents and independent evaluators can call the same fixture directly. The response includes the example request, detected characteristics, all observed matches, the target pack’s questions and requirements, methodology versions, and explicit limitations.
A reproducible public check
Change AUT-001 to any published pack identifier. A successful response reports result: "passed" only when the target pack appears in the live observed match set.
The case library is versioned separately so changes to examples can be distinguished from changes to packs or methodology.
The directive is the canonical contract between what the user decided, what remains open, and what the coding agent is expected to implement and report.
Canonical first, readable second
The compiler emits .agentdirective/agent-directive.json first. Markdown instructions, implementation prompts, status templates, and manifests are derived from the same object so they cannot drift through separate authoring.
A requirement carries its decision state
A confirmed parameter can be implemented. An unresolved parameter remains visible in unresolved_decisions and must not be silently filled by the agent.
Stable IDs link controls, decisions, tests, observability, evidence, and later status reports.
.agentdirective/agent-directive.jsonCanonical requirements and traceability.
.agentdirective/control-status.jsonOne agent-reported implementation state per requirement.
.agentdirective/control-events.jsonlAppend-only material changes and reassessments.
.agentdirective/IMPLEMENTATION_PROMPT.mdReadable instructions derived from the directive.
manifest.jsonBundle contents and SHA-256 checksums.
Requirement drift
If a later request conflicts with a confirmed requirement, the coding agent should stop and surface the conflict. Weakening, removing, or rejecting a safeguard is a new decision and a new event—not a silent edit.
Learn
Evidence and review
AgentDirective separates an implementation claim, the evidence pointers supplied for it, and the result of a bounded metadata review.
Three layers that must not be collapsed
1Agent-reported status
The coding agent says whether a requirement is implemented, partial, unresolved, not applicable, or rejected.
2Evidence pointers
Relative file paths, named tests and outcomes, telemetry names, procedures, or safe digests support the claim without embedding source.
3Review result
The reviewer determines whether the submitted metadata supports, omits, or contradicts the claim within the selected scope.
Report status without overstating it
Evidence is structured and bounded
A test has an explicit result. A path must be repository-relative. A partial status must state what remains.
implemented means “the agent reports this exists,” not “AgentDirective independently verified the behavior.”
Submitted metadata is consistent for the narrow check performed.
unsupported
Expected status or evidence is absent.
contradicted
A supplied test, status, or artifact conflicts with the claim.
unverifiable
The package cannot establish the claim without source or runtime inspection.
not_reviewed
The check falls outside the selected review scope.
Privacy boundary
Safe to submit
Directive and status metadata
Repository-relative paths
Test names and outcomes
Telemetry event names
Short implementation summaries
Known limitations and safe digests
Do not submit
Source code or file contents
Secrets, credentials, or environment values
Personal or customer data
Production records or raw logs
Absolute paths or repository URLs
Proprietary build artifacts
Use
Existing projects
Assess a project that was built before AgentDirective without connecting its repository or uploading source code.
The read-only assessment flow
Describe
Provide a high-level project description
Mention users, data, integrations, important actions, automation, and AI features.
Plan
Generate a project-specific checklist
Deterministic matching selects applicable packs, requirements, evidence expectations, and open questions.
Inspect
The coding agent reads the repository locally
It does not change files and returns only the bounded assessment object.
Audit
Submit sanitized metadata
The reviewer prioritizes unsupported, contradictory, partial, and unverified claims.
Improve
Return a bounded improvement prompt
The agent receives the gaps but must still ask the user about every open decision.
Let a connected agent handle the handoff
Two purpose-built MCP tools
agentdirective_existing_project_plan returns the checklist and assessment template. After local inspection, agentdirective_existing_project_audit accepts the sanitized object and returns findings.
The web workflow remains available for agents without remote MCP support.
Use AgentDirective to review this existing project.
1. Call agentdirective_existing_project_plan.
2. Inspect the repository locally and read-only.
3. Do not send source, secrets, personal data, or absolute paths.
4. Call agentdirective_existing_project_audit with the sanitized assessment.
5. Present the findings and ask me about every open decision.
Use
MCP and API
Connect an MCP-capable coding agent to the same versioned methodology used by the web application, or call the public HTTP routes directly.
Remote MCP endpoint
The hosted endpoint speaks JSON-RPC 2.0 over HTTP. It requires no account or API key and receives no repository access.
Remote MCP serverhttps://agentdirective.org/mcp
agentdirective_analyze
Detect characteristics, match packs, and return open questions.
agentdirective_compile
Compile a canonical bundle from the user’s answers.
agentdirective_review
Run the bounded directive metadata review.
agentdirective_existing_project_plan
Create a read-only checklist for an existing project.
agentdirective_existing_project_audit
Review the sanitized existing-project assessment.
agentdirective_packs
Read the versioned Control Pack library.
Call a tool over JSON-RPC
Analyze before writing code
The response contains detected characteristics, applicable packs, and questions for the user. It deliberately does not contain answers to those questions.
Most MCP clients configure the endpoint as a remote server; direct JSON-RPC is shown here to make the protocol behavior concrete.
HTTP request
POST https://agentdirective.org/mcp
Content-Type: application/json
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "agentdirective_analyze",
"arguments": {
"description": "A support assistant reads customer messages and can issue refunds."
}
}
}
Public HTTP routes
GET /api/methodologyPublished versions, counts, modes, and limitations.
GET /api/packsCanonical Control Pack library.
GET /api/vocabularyRecognized platform names and their review cues.
GET /api/benchmarkVersioned benchmark dataset and current results.
POST /api/compileCompile a directive from description, characteristics, and decisions.
POST /api/existing-project/planCreate a read-only existing-project assessment plan.
POST /api/existing-project/auditReview a sanitized existing-project assessment.
POST /api/reviewReview a sanitized directive/status package.
Reference
Artifacts and schemas
The public data contracts make directives, packs, status, events, manifests, and review reports portable and independently inspectable.
Core artifacts
ArtifactRoleAuthority
agent-directive.jsonRequirements, decisions, tests, observability, and traceability.Canonical
control-status.jsonCoding-agent-reported status and evidence pointers.Reported
control-events.jsonlAppend-only implementation and reassessment history.Historical
manifest.jsonBundle file list and integrity digests.Integrity
review-report.jsonBounded findings and explicit limitations.Review result
Published schemas
Schemas use JSON Schema Draft 2020-12. The links below resolve to the exact machine-readable contracts served by AgentDirective.