A minimal specification that requires autonomous systems to declare operational boundaries before execution.
It standardizes how AI agents declare identity, constraints, autonomy level, risk posture, and data handling prior to interacting with external systems.
This repository defines a declaration layer only.
It does not define behavior. It defines boundaries.
Agent Manifest does not execute, validate, score, enforce, or decide.
You can integrate Agent Manifest in under five minutes.
manifest.json{
"manifest_version": "0.1.0",
"agent_id": "my.agent",
"agent_name": "My Agent",
"agent_version": "1.0.0",
"owner": {
"type": "organization",
"identifier": "My Company"
},
"purpose": {
"primary_code": "general.assistance",
"description": "Provides bounded assistance without irreversible execution."
},
"forbidden_actions": [],
"autonomy": {
"level": 1
},
"risk_profile": {
"level": "low"
},
"data_handling": {
"stores_personal_data": false
}
}
ajv validate -s spec/manifest.schema.json -d manifest.json
Done.
Your agent now declares its boundary surface before execution.
{
"manifest_version": "0.1.0",
"agent_id": "example.minimal.agent",
"agent_name": "Minimal Example Agent",
"agent_version": "1.0.0",
"owner": {
"type": "individual",
"identifier": "Example Owner"
},
"purpose": {
"primary_code": "general.assistance",
"description": "Provides bounded general assistance without executing irreversible actions."
},
"forbidden_actions": [
"execute_financial_transactions",
"access_private_data_without_consent"
],
"autonomy": {
"level": 1
},
"risk_profile": {
"level": "low"
},
"data_handling": {
"stores_personal_data": false
},
"stopping_authority": {
"stoppable_by": [
"owner"
],
"mechanism": "Agent can be halted via manual override by the declared owner.",
"stages": [
"pre-execution",
"mid-execution"
]
},
"audit_surface": {
"logging": "basic",
"reconstructability": "partial",
"opacity_declared": false
},
"contact": {
"email": "contact@example.com"
}
}
This example is non-normative and provided for structural clarity.
Full structural reference can be found in the spec/
directory.
For additional examples see:
examples/
As AI systems become increasingly autonomous, interactions between agents, humans, APIs, and infrastructures require clarity prior to execution.
Most systems describe capabilities.
Few describe constraints.
Agent Manifest introduces a structural principle:
Autonomous systems should declare boundaries before action.
This specification provides a public declaration layer — not a runtime, not a framework, not a governance engine.
It is designed to be:
Agent Manifest is a declarative surface that may include:
It is intentionally minimal and does not mandate internal architecture.
Agent Manifest does not:
It defines what an agent declares — not what it does.
Validation, scoring, auditing, and enforcement belong to separate systems.
The normative specification contract is defined in:
The constitutional core is defined in:
See: STABILITY.md and
VERSIONING_POLICY.md
If you are new to Agent Manifest, read in this order:
The structural reasoning behind the specification is documented in:
This document explains the architectural decisions, boundary-first philosophy, autonomy model, and execution-agnostic design principles that shape Agent Manifest.
Agent Manifest may be referenced during security and governance review of autonomous systems.
For structured review guidance, see:
Agent Manifest is built around three structural ideas:
The specification is designed to evolve alongside AI systems without becoming dependent on any specific model, vendor, or orchestration framework.
It is compatible with:
Agent Manifest is supported by a set of structural and doctrinal documents that clarify its governance philosophy and evaluation posture.
These documents are non-normative and do not modify the schema contract.
Pre-Execution Authority
Authority must be declared before autonomy or execution.
foundations/pre-execution-authority/
Incident Analysis — Architectural Gap Patterns
Recurring structural governance absences mapped to the declaration layer.
foundations/INCIDENT_ANALYSIS.md
Declarative Integrity Framework (DIF)
A structural evaluation lens for assessing manifest coherence and completeness.
foundations/DECLARATIVE_INTEGRITY_FRAMEWORK.md
Agent Manifest does not grow by accumulation.
It grows by refinement.
This project optimizes for:
See: ROADMAP.md
Agent Manifest operates strictly at the Declaration Layer.
It does not execute agents.
It does not enforce policy.
It does not perform runtime validation.
Instead, it standardizes how agents declare:
The ecosystem separates into three distinct layers:
Agent Manifest (this repository)
Defines how boundaries and commitments are declared.
Validators, policy engines, audit systems, and compliance tooling.
These systems verify whether declarations are internally consistent and
externally respected.
Agents and runtimes that perform actions.
Without structured declaration, validation is impossible.
Without validation, accountability collapses.
Without accountability, autonomy becomes opaque.
This repository defines the open specification.
Interpretations, validators, scoring engines, and audit systems may be built independently and are not part of this core specification.
Proposals for modification must preserve the core principles defined in
CORE_PRINCIPLES.md.
Agent Manifest defines declarations only.
Enforcement systems may validate:
The specification itself performs no validation.
For common misunderstandings, see:
MISCONCEPTIONS.md
Illustrative, non-normative manifests can be found in the
examples/ directory.
Agent Manifest follows semantic versioning:
Documentation and examples may evolve while manifest_version remains
0.1.0 until a formal spec bump is declared.
Agent Manifest proposes a structural layer for autonomous systems:
Agents should be able to declare who they are, what they can do, and where their boundaries lie before interaction begins.
This specification remains neutral, minimal, and open.
Its value emerges through adoption.
Agent Manifest is grounded in the principle of Pre-Execution Authority.
Before autonomy, execution, or capability, an agent must declare the authority framework under which it operates.