[AgentHook]AGENTHOOK ☰ Gap Standards Portfolio Flow Attestation Contract Spec Glossary Tests Runtimes Governance Paper Demo GitHub Open interface standard for agent runtimes ⚠ AI governance frameworks need runtime evidence · EU AI Act · ISO/IEC 42001 · NIST AI RMF · Colorado AI Act · SOC 2 One interface for agent runtimes to work with governance, approval, context, and audit systems. AgentHook^(™) is an open technical specification for agent runtime interoperability: emit lifecycle events, honour allow, deny, and ask decisions, and produce evidence that any conforming governance stack can consume. Agent runtimes should not need bespoke integrations for every policy engine, approval workflow, knowledge layer, or audit system. Implement AgentHook once and interoperate through a stable runtime contract. Read the spec → View governance Try the AgentHook reference demo v0.2 draft · Apache License 2.0 · perpetual no-relicence pledge Runtime vendor contract Implement AgentHook once. Interoperate with every conforming governance stack. AgentHook defines the small boundary an agent CLI, SDK, framework, or runtime needs to expose. The runtime emits standard lifecycle events and honours standard decisions. Governance, approval, context, and audit systems then plug in behind that boundary without every vendor writing bespoke integrations. The boundary is publisher-agnostic. Publishers keep their native tool names and inputs, but also emit normalized action, resource_kind, resource, resource_scope, and operation_risk fields so subscribers can govern a file read, folder write, database query, URL open, email send, package install, or repository publish without brittle per-runtime parsing. Emit: lifecycle events including SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, model, error, and session events. Honour: allow proceeds, deny hard-blocks, ask pauses until the referenced approval workflow is approved, denied, or expires. Prove: record event ids, session ids, action ids, approval workflow ids, runtime attestation, and admission verdicts. Normalize: preserve native tool_name and tool_input, then add portable operation fields so policy can match semantics rather than a vendor's command shape. Align: if the runtime exposes /goal or task objectives, emit goal lifecycle evidence with goal_id, goal_source, constraints, lineage, and terminal scope. Goal requirements for vendors AgentHook should carry native goal state, not invent a second planning system. Agent CLIs and runtimes are starting to expose explicit goals, tasks, and continuation loops. AgentHook does not replace those controls. A conforming publisher should absorb the runtime's native goal state and emit it as portable evidence so governance subscribers can check whether proposed actions remain aligned with the active objective. Goal source: expose the native goal lifecycle. When a user or runtime sets a goal, emit GoalSet with goal_id, goal_source, goal text or reference, constraints, owner, and linked session identifiers. Alignment: make status observable. Emit GoalStatus whenever the goal becomes active, met, failed, blocked, paused, or superseded. Include the status reason and the event or evidence reference that justifies the transition. Lineage: preserve the run tree. Include root_session_id, parent_session_id, lineage_session_ids, and depth where available so external runtimes can aggregate spend, stops, approvals, and receipts across a whole agent tree. Terminal scope: separate child stop from run stop. Terminal events should declare whether they are terminal for the child, parent, root session, or full run. This avoids false "done" states when one delegated agent ends but the root objective is still active. The evidence gap AI governance is becoming a runtime interoperability problem. Policies, risk registers, and management systems are necessary, but they cannot prove what an agent actually did at runtime. Agent runtimes expose prompts, model calls, tool calls, approvals, denials, and responses inconsistently. Without a shared envelope, every operator rebuilds the same evidence plumbing per vendor, and auditors cannot compare agent behaviour across systems. 1 One runtime interface Lifecycle events are emitted once and consumed by policy, context, approval, audit, workflow, and observability subscribers. N×M Bespoke integrations per provider, per subscriber Without a standard, each agent runtime and each governance tool needs custom glue. Costs scale with vendor count multiplied by subscriber count. Portfolio Patterns need comparable evidence Boards, auditors, accreditors, and investors need to see runtime patterns across teams and entities, not isolated policy documents. Standards map AgentHook is the agent runtime interface layer, not a replacement for governance frameworks. ISO 42001, NIST AI RMF, EU AI Act logging obligations, state AI laws, OpenTelemetry, CloudEvents, W3C Trace Context, IETF RATS, SPIFFE/SPIRE, in-toto/SLSA, Sigstore, C2PA, and policy engines such as Microsoft AGT solve adjacent problems. AgentHook defines the missing agent-specific runtime boundary that lets those systems receive events, return decisions, request approvals, and preserve evidence. Governance Risk and management frameworks ISO/IEC 42001, NIST AI RMF, EU AI Act obligations, and US state AI laws (Colorado AI Act, with California, Texas, and others in motion) define process, accountability, and risk vocabulary. AgentHook supplies the runtime evidence those programmes can use. Observability Traces, events, and correlation OpenTelemetry, CloudEvents, and W3C Trace Context move telemetry through systems. AgentHook defines the AI-agent lifecycle semantics carried in that telemetry. Trust Attestation and provenance IETF RATS, SPIFFE/SPIRE, in-toto/SLSA, Sigstore, and C2PA inform identity, provenance, and attestation design. AgentHook applies those patterns to agent runtime controls. Publisher Stable runtime identity AgentHook publisher manifests declare the runtime, source label, supported lifecycle events, limitations, installer metadata, and verification status in a single local-first file. Policy Policy engines and gates Policy engines, semantic gates, workflow systems, redaction systems, and custom subscribers can consume AgentHook events and return standard decisions: allow, deny, or ask. Assurance Audit, assurance, and attestation programmes SOC 2 Type II, ISO/IEC 27001, and emerging AICPA SOC for AI work define the evidence formats assurance professionals expect. AgentHook produces runtime events those programmes can ingest as primary evidence. Reference Reference implementations Reference implementations can prove the specification in practice. Conforming implementations do not need any specific bus, policy engine, subscriber, or vendor runtime. Boundary What AgentHook does not claim AgentHook does not certify legal or regulatory compliance. It does not replace a GRC platform, an AI management system, or an audit programme. It makes runtime evidence portable so those systems can do their work. Draft AHP-004: Runtime Attestation A draft non-breaking extension that lets a publisher declare which hooks, gates, subscribers, consolidation rules, and fail modes are active for the current session. Attestation distinguishes verified runtime facts from user-authored prompt text and is carried inside the existing envelope. Read AHP-004 → Draft AHP-005: Governance Context Metadata A draft AgentHook Proposal defines optional metadata.governance_context fields for carrying current task, policy, and workflow context inside the existing envelope. The metadata is advisory context for policy, audit, workflow, and observability subscribers; it is not an authorisation decision by itself. Read AHP-005 → Draft AHP-006: Managed Runtime Identity and Device Registry A draft enterprise metadata convention that lets participating publishers describe their runtime instance, device or workload binding, approval reference, and verification strength. AgentHook does not claim network-wide AI discovery; activity outside the registry remains the responsibility of existing MDM, EDR, SASE, identity, and procurement controls. Read AHP-006 → Draft AHP-009: Runtime Contract Discovery File Set A draft proposal covering AgentHook.md, agenthook.lock.json, agenthook.signature, and the RuntimeContractLoaded event. Until AHP-009 is accepted, the file set is a high-assurance draft pattern, not a mandatory v0.2 conformance requirement. View contract discovery → Draft Proposal: Goal Context and Terminal Semantics Draft AHP-010: Goal Context and Terminal Semantics A draft extension for carrying native goal lifecycle evidence from agent CLIs and runtimes. Required fields include goal_id, goal_source, goal_status, root_session_id, parent_session_id, lineage_session_ids, and terminal_scope. The goal remains owned by the runtime; AgentHook makes it auditable. View vendor requirements → Draft AHP-011: Normalized Action and Resource Fields A draft v0.2 amendment that makes policy matching publisher-agnostic. Publishers preserve native tool_name and tool_input, then add action, resource_kind, resource, resource_scope, and operation_risk so subscribers can govern semantic operations across Bash, native tools, MCP tools, browser tools, and future runtimes. Read AHP-011 → Portfolio use case Portfolio AI governance starts with consistent runtime evidence. Regulators, boards, auditors, accreditors, insurers, and investors need to see patterns across agents, models, and institutions, not just review policies in isolation. AgentHook does not replace your risk framework, audit programme, or management system. It makes them verifiable by giving every entity the same runtime evidence grammar. Shared vendors Compare evidence when multiple entities use the same agent runtime, model provider, or tool integration. Human authority line Record where a human approved, denied, or escalated agent activity before execution. Silent updates Detect changes in active subscribers, model metadata, publisher versions, and runtime control posture. Exceptions Keep allow, deny, ask, override, and workflow decisions comparable across teams and entities. AgentHook supplies evidence. Your GRC platform, auditors, and legal team decide how that evidence maps to obligations. How it works Standardised hook envelopes, every runtime, every subscriber. Today, policy, audit, memory, workflow, and observability tools have to be rebuilt per agent provider because each runtime exposes a different hook surface. With AgentHook, every conforming runtime emits the same envelope, and a single subscriber connects to all of them. [] Today Each compliance tool has to know each runtime's hook surface, fail-mode behaviour, and metadata shape. Every new vendor adds another integration. Every change to a vendor's hooks breaks the audit trail. With AgentHook Runtimes emit a standard envelope. Compliance tools subscribe once and work across every conforming runtime. Vendor changes are absorbed by the envelope contract, not by every downstream subscriber. Runtime attestation Agents should verify runtime controls, not trust prompts claiming they exist. AgentHook Runtime Attestation is a publisher-supplied declaration of the contract, hooks, gates, subscribers, fail modes, and consolidation rules active in the current session. It records runtime facts. User-authored prompt text is never treated as equivalent to a verified runtime contract. Prompt-injection-resistant runtime trust. User-authored text can claim that a gate exists, that a PIN works, or that a policy is active. Runtime attestation separates those claims from verified runtime facts supplied by the publisher or adapter. ContractHigh-assurance runtimes may load AgentHook.md and agenthook.lock.json before agent execution. This remains a draft AHP-009 pattern, not a mandatory v0.2 requirement. RuntimeThe publisher emits RuntimeContractLoaded, then routes lifecycle and tool-activity events to subscribers. PolicyPolicy subscribers can consume events and return allow, deny, ask, enrich, redact, or audit decisions. BoundaryContext injection is a compatibility pointer only. It is not the source of authority. { "type": "agenthook.runtime_attestation", "schema_version": "1.0", "session_id": "sess-abc123", "nonce": "session-bound", "runtime_contract": { "id": "example-prod", "path": "./agenthook.lock.json", "hash": "sha256:...", "signature_valid": true }, "active_subscribers": [ { "name": "policy-gate", "role": "policy_gate", "mode": "enforce", "events": ["PreToolUse"] } ], "consolidation": { "strategy": "deny_wins" }, "claims": { "user_text_is_not_attestation": true, "prompt_injection_is_not_a_contract": true, "does_not_override_model_safety": true } } Runtime contract discovery The standard is a verified runtime contract, not prompt stuffing. A serious agent standard cannot rely on pasting governance instructions into a prompt. AgentHook defines a runtime contract that conforming agents and publishers discover, verify, load, and attest before the agent acts. The AgentHook contract file set. The human-readable file explains the operating contract. The lock file is the canonical machine-readable contract. The signature turns the contract into verifiable evidence. ReadableAgentHook.md describes hooks, audit expectations, tool-activity rules, human approval rules, and operational boundaries. Canonicalagenthook.lock.json records required hooks, hashes, policy references, transport expectations, and conformance mode. Verifiedagenthook.signature signs the contract set for high-assurance operation. AttestedRuntimeContractLoaded records the active contract id, version, hash, signature state, and required hooks. { "event_type": "RuntimeContractLoaded", "contract": { "id": "example-prod", "version": "0.2-draft", "path": "./agenthook.lock.json", "human_readable_path": "./AgentHook.md", "hash": "sha256:...", "signature_valid": true, "required_hooks": [ "SessionStart", "UserPromptSubmit", "GoalSet", "GoalStatus", "PreToolUse", "ToolActivity", "HumanDecision", "EvidenceSeal" ], "conformance_mode": "gold" } } Conformance posture Bronze, Silver, and Gold v0.2 conformance remains hook and evidence based. Publishers may discover AgentHook.md and record its digest, with AGENTHOOK.md recognised as a compatibility alias. agenthook.lock.json loading and signature verification are high-assurance draft AHP-009 behaviours, not mandatory Silver requirements. Publisher manifests Every publisher should describe itself before it is trusted. A conforming publisher SHOULD ship an agenthook.publisher.json file at the repository root. The manifest gives collectors and operators one place to inspect identity, event coverage, limitations, configuration files, and verification status before live events are observed. A simpler onboarding contract. The manifest does not install code and it does not make policy decisions. It is declarative metadata that lets a collector show what a publisher claims to support, then verify that claim by observing real runtime events. IDStable reverse-DNS publisher ID, such as uk.agenticthinking.publisher.anthropic.claude-code. RuntimeVendor, runtime name, tested versions, source label, and config files. CoverageEach canonical lifecycle event is marked supported, partial, planned, or not exposed. BoundaryNo secrets, tokens, private endpoints, policy rules, or executable install logic. { "schema": "https://agenthook.org/schemas/publisher-manifest.v1.json", "schema_version": "1.0", "publisher_id": "uk.example.publisher.runtime", "display_name": "Example AgentHook Publisher", "maintainer": { "name": "Example Maintainer", "url": "https://example.com" }, "runtime": { "vendor": "Example", "name": "Example Agent CLI", "versions_tested": ["1.0.0"] }, "agenthook": { "version": "0.1", "source": "example-cli", "events": { "SessionStart": "supported", "UserPromptSubmit": "supported", "GoalSet": "supported", "GoalStatus": "supported", "GoalCleared": "supported", "PreLLMCall": "not_exposed", "PostLLMCall": "not_exposed", "PreToolUse": "supported", "PostToolUse": "supported", "ModelResponse": "partial", "SessionEnd": "not_exposed", "AgentHandoff": "not_exposed", "ErrorOccurred": "not_exposed" } }, "entrypoints": { "command": "bin/example-gate", "installer": "install.sh" }, "config": { "files": ["~/.example/hooks.json"] }, "limitations": ["Raw LLM hooks are not exposed."], "verification": { "self_attested": true, "conformance": "pending", "last_tested": "2026-04-28", "commands": ["example-gate --self-test"] } } Manifest schema → Manifest examples → Implementing Two minimal examples. Drop in, emit events, you're conformant. Any host language, any transport. The wire format below is the core contract a publisher commits to. A subscriber listens and responds with verdicts the publisher honours. Runtime contracts are loaded before execution, then attested in the event stream. Publisher manifests sit beside the code, declaring identity and hook coverage. Validate every event against envelope.schema.json. Publisher · Python import httpx, uuid, datetime as dt def emit(event_type, **fields): event = { "schema_version": 1, "event_id": str(uuid.uuid4()), "event_type": event_type, "timestamp": dt.datetime.now(dt.timezone.utc).isoformat(), "source": "your-runtime", **fields, } httpx.post("http://agenthook-collector:18800/event", json=event, timeout=5) emit("PreToolUse", tool_name="Bash", tool_input={"command": "git push"}) Subscriber · Python from fastapi import FastAPI app = FastAPI() @app.post("/event") async def receive(event: dict): if event["event_type"] == "PreToolUse": cmd = event.get("tool_input", {}).get("command", "") if "git push" in cmd: return {"verdict": "deny", "reason": "review push first"} return {"verdict": "allow"} The example uses a neutral collector URL. Any conforming publisher, bus, adapter, or collector may implement the envelope and delivery semantics. Reference implementations exist; they are not required for conformance. Publishers should also ship agenthook.publisher.json so collectors can inspect declared coverage before verifying live events. The specification Core lifecycle, decisions, approvals, and evidence. One runtime interface. Apache 2.0. AgentHook v0.2 defines the wire-format envelope and 10 core lifecycle events. Draft AHP extensions add 9 draft extension events covering runtime contracts, approvals, goal context, tool activity, human decisions, incident signals, and evidence sealing. It is implementation-neutral: any transport, any host language, provided the envelope and semantics are honoured. Event Phase Description RuntimeContractLoaded before The runtime discovered, loaded, and verified the active AgentHook contract before execution. CapabilityReport state The publisher reports supported hooks, field coverage, capture methods, and conformance metadata. PreToolUse before The agent is about to execute a tool call. ToolActivity during Material activity happened inside a non-atomic tool call, linked to the parent tool event. PostToolUse after The tool call returned, or threw. UserPromptSubmit before The user submitted a prompt to the agent. PreLLMCall before The agent is about to call its LLM. PostLLMCall after The LLM call returned. Carries reasoning and response content for transcript-grade records when the provider exposes it. ModelResponse after The model has finished generating its response. ContextInject before A short pointer to the verified runtime contract was surfaced. This is compatibility/awareness only, not authority. HumanApprovalRequested before A subscriber, policy, or runtime asked a human to approve, reject, override, or amend an action. HumanDecision after A named human decision was recorded with scope, rationale, authority, and timestamp. SessionStart state A new agent session began. SessionEnd state An agent session ended. AgentHandoff during The agent is delegating to another agent. IncidentSignal after A runtime, subscriber, or monitor recorded a potential safety, policy, security, or operational incident. EvidenceSeal after A collector sealed an evidence bundle, export, or replay segment with retention and integrity metadata. ErrorOccurred after An error was raised that did not terminate the session. Implementations may emit additional event types using PascalCase names. Subscribers may ignore unknown types. Buses must not reject events on unrecognised event_type. Read the full specification → Conformance As-is tiers now. Platinum high-assurance profile next. A publisher claims an as-is tier based on the hook surface available today. A test rig verifies the claim. The to-be Platinum profile adds the draft high-assurance controls from the AHP process: signed contract discovery, runtime attestation, richer evidence sealing, goal lineage, and terminal semantics. Bronze Lifecycle correctness Publisher emits the core lifecycle event types with the envelope format. Required fields populated, valid JSON, valid event_id, valid timestamp. Runtime contract digest recorded where available. Threshold: 80% pass on Bronze test set Tests envelope schema validation, required field presence, event type emission, and timestamp validity across the canonical lifecycle. Silver Contract and transcript Bronze plus matched Pre and Post LLM call pairs, model/provider metadata, token counts, and response content. Threshold: 80% pass on Silver test set Tests Bronze conformance plus runtime contract loading and matched PreLLMCall/PostLLMCall pairs with correct model, provider, and token-count metadata. Gold Broad current hook coverage Silver plus broad current support for prompt, model, tool, reasoning, and session lifecycle events where the runtime exposes them. Threshold: 80% pass on Gold test set Tests Silver conformance plus current high-coverage lifecycle capture and correlation across available runtime hooks. Platinum To-be high-assurance profile Gold plus accepted AHP controls for signature verification, runtime attestation, ToolActivity, human decisions, incident signals, evidence sealing, goal lineage, and terminal scope. Status: draft AHP profile Platinum is the future high-assurance target. It should not be used to downgrade current Gold candidate runtimes until the relevant AHPs and test harness are accepted. Coming soon: HookBus Agent. HookBus Agent is being built as the open-source reference runtime for governance-native AgentHook execution and the highest AgentHook assurance profile: native runtime contracts, pre-action decision points, replayable evidence, and tamper-evident audit records. AgentHook remains vendor-neutral. HookBus Agent is one reference implementation, not a requirement for conformance. The AgentHook Conformance Fixture exercises the complete AgentHook surface. A minimal reference fixture emits the v0.2 core lifecycle plus draft extension events through a collector or bus with a single preflight command. It is deliberately small: a fixture for hook coverage, ordering, metadata, and reasoning visibility, not a production agent SDK. The broader Platinum agentic runtime is being built as the example high-assurance implementation. agenthook-fixture --preflight emits a deterministic lifecycle run. Provider reasoning smoke tests are configured through a compatible model endpoint; the standard itself remains LLM-agnostic. AgentHook Conformance Fixture on GitHub → SessionStart RuntimeContractLoaded UserPromptSubmit GoalSet GoalStatus PreLLMCall PostLLMCall ModelResponse PreToolUse ToolActivity PostToolUse HumanDecision AgentHandoff IncidentSignal EvidenceSeal ErrorOccurred SessionEnd Runtime support Where each agent runtime stands today. A current audit of which hook surfaces each major agent runtime exposes. Candidate tiers show the as-is Bronze/Silver/Gold coverage available today. Platinum is the to-be high-assurance profile and is not used to score current publishers yet. Audit method: direct inspection of each runtime's published hook surface and public Agentic Thinking publisher repositories as of 19 May 2026. Gold candidate and Silver candidate mean the runtime currently exposes enough hooks for that as-is v0.2 coverage profile. Platinum means the future high-assurance target after the relevant AHP drafts and conformance test harness are accepted. Runtime providers may self-attest by Pull Request to the AgentHook repository. Self-attested rows will be marked accordingly. This audit is for technical interoperability comparison, not procurement guidance. Next scheduled review: 2 June 2026, then fortnightly while publisher coverage is changing. Runtime UserPromptSubmit Pre / Post LLMCall Pre / Post ToolUse Reasoning capture Coverage Status AgentHook Conformance Fixturereference fixture for the AgentHook standard yes yes / yes yes / yes yes Platinum target Reference fixture only GitHub HookBus AgentAgentic Thinking reference implementation yes yes / yes yes / yes yes Platinum target Example Platinum runtime under construction GitHub HermesNousResearch yes yes / yes yes / yes yes Broad hook coverage Publisher shipped; conformance pending GitHub OpenCodeopen source yes yes / yes yes / yes yes Broad hook coverage Publisher shipped; conformance pending GitHub Claude CodeAnthropic yes no / no yes / yes partial Core hook coverage Publisher shipped; conformance pending GitHub Codex CLIOpenAI yes no / no partial / partial partial Core hook coverage Publisher shipped; conformance pending GitHub AmpSourcegraph yes no / no yes / yes no Core hook coverage Publisher shipped; conformance pending GitHub OpenClawopen source no no / output only yes / yes no Partial shipped Publisher shipped; partial runtime surface GitHub Gemini CLI, Cursor, OpenAI Agents SDK, GitHub Copilot CLI, Cognition Devinpublisher pending . . . . Pending Pending Pending rows will be filled as each runtime's hook surface is reviewed and validated against the conformance test suite. Self-attested rows and test harness verified rows will be marked accordingly. Microsoft Agent Governance Toolkit is tracked as a control/subscriber layer, not as an agent runtime publisher. Governance Binding licensing commitments. Stewardship that transfers on conditions, not on a calendar. The specification is published and stewarded by Agentic Thinking Limited (UK), a private company limited by shares (company number 17152930). Stewardship is provisional. The steward will transfer governance to a neutral, vendor-independent foundation when the specification has reached version 1.0 stability and at least one of the following has occurred: three or more leading commercial agent runtime providers have implemented AgentHook natively; three or more independent open-source runtimes have implemented it natively, with at least one alternative AgentHook-conformant collector existing in the wild; or the European AI Office, NIST, the UK AI Safety Institute, or an equivalent recognised body has cited the specification in formal published guidance. The following commitments are binding on the steward and any successor. 01 Apache License 2.0 in perpetuity The licence shall not be replaced, restricted, or supplemented with additional terms by the steward or any successor. 02 No royalty fees No fee may be charged for the right to implement the specification, claim conformance, or use the AgentHook name in describing an implementation. 03 No participation gating Any individual or organisation may submit Proposals and contribute to working-group discussion. Vote-eligible seats are limited to founding and elected members; this does not restrict contribution. 04 Patent grant Royalty-free, irrevocable patent licence to any party implementing the specification. Survives any change of stewardship. 05 Right to fork The specification may be forked at any time under Apache 2.0. The steward may not assert trademark rights against forks (provided the forks do not represent themselves as the official specification). 06 Twelve-month notice on changes Any amendment to the Charter or to these commitments requires twelve months' public notice and unanimous Working Group approval. These commitments are documented in CHARTER.md and are binding on the steward and any successor. The Working Group composition, voting rules, and AgentHook Proposal (AHP) process are documented in GOVERNANCE.md. Stewardship transfer is conditional on the triggers above and is not gated on a calendar. Read the Charter → Working Group rules → The paper A runtime evidence standard for auditable AI agent governance. The AgentHook specification is accompanied by a draft technical paper that sets out the problem, the architecture, the envelope model, runtime attestation, governance context metadata, and conformance tiers in detail. Ruocco, P. (2026). AgentHook: A Runtime Evidence Standard for Auditable AI Agent Governance. Zenodo. Read the paper → Cite this work → DOI: 10.5281/zenodo.19853376. Get involved The specification is pre-v1.0. Contributions, implementations, and conformance trials are welcomed. Working group composition is being finalised ahead of the public draft. Any individual or organisation may contribute to discussion in GitHub Issues. Substantive specification changes follow the AgentHook Proposal (AHP) process. Spec Read the specification Envelope format, 10 core lifecycle events plus draft extensions, hook delivery semantics, and conformance tiers. SPEC.md → Propose Submit an AgentHook Proposal Substantive changes go through the AHP process, modelled on Python PEPs and Rust RFCs. PROPOSALS/ → Manifest Add publisher metadata Declare publisher identity, runtime, supported events, limitations, and verification commands in one local-first file. publisher-manifest.schema.json → Discuss Open an issue Questions, edge cases, integration notes, conformance test feedback. All on GitHub. Issues → Steward Agentic Thinking Limited The provisional steward of the AgentHook specification and maintainer of reference implementation work. agenticthinking.uk → [AgentHook]AGENTHOOK An open technical specification for AI-agent runtime evidence. Apache 2.0 in perpetuity. Stewarded by Agentic Thinking Limited (UK). Spec - Specification - Publisher manifest - Conformance - Proposals Governance - Charter - Working Group - Members Project - GitHub - Reference implementation - Steward Stewarded by Agentic Thinking Limited · Company 17152930 (England and Wales) · agenticthinking.uk HookBus™ and AgentHook™ are trade marks of Agentic Thinking Limited. The AgentHook specification is licensed under the Apache License, Version 2.0. Cite: Ruocco, P. (2026). AgentHook: A Runtime Evidence Standard for Auditable AI Agent Governance. Zenodo. https://doi.org/10.5281/zenodo.19853376 AgentHook is a technical specification for runtime evidence. Adoption of AgentHook does not certify or imply compliance with any law, regulation, or standard. Compliance determinations remain the responsibility of the implementing organisation and its auditors, legal counsel, and regulators.