Actenon

Authority enforcement and verifiable evidence for autonomous systems. An agent shouldn't be able to take a consequential action without scoped, signed authority for that exact action — and every action should leave proof a third party can verify.

Guarantee precondition: the edge guarantee holds when the protected edge is the only path to the resource, the backend accepts only brokered credentials issued after verification, and the agent has no standing credential or alternate route. Actenon still refuses invalid proofs if those conditions are not met — but it cannot prevent a caller that bypasses the protected edge from reaching the resource. Full scope in actenon-kernel/docs/SCOPE_AND_GUARANTEES.md.

Start here

pip install actenon-scan && actenon-scan scan .

Find the execution gap in your own code in 10 seconds. Then:

actenon-permit — the reference enforcement demo. pip install actenon-permit → permit demo.
actenon-kernel — the proof gate. The trust anchor that verifies every action at the execution edge.
actenon-protocol — the wire contract. Zero dependencies, any language, any framework.
actenon-cloud — the hosted control plane. Optional.

The problem

Modern agent stacks answer the upstream question — should this requester be allowed to do this kind of thing? — with authentication, policy engines, approval workflows, and audit logs. They still leave open the question the execution edge needs to answer:

Is the exact action about to execute still the exact action that was authorized — for this endpoint, this tenant, this subject, this target, this scope, this time window, and this single execution attempt?

That unanswered question is the execution gap. Actenon closes it.

The Actenon ecosystem

Repo	Role	Depends on
`actenon-protocol`	The neutral wire contract. Zero dependencies.	nothing
`actenon-kernel`	The open verifier. Verifies proofs at the execution edge; issues no grants; runs no policy decisions.	`actenon-protocol`
`actenon-permit`	The developer on-ramp + authority broker. Issues signed grants, runs the PDP, brokers credentials.	`actenon-kernel`, `actenon-protocol`
`actenon-cloud`	The optional managed control plane. Multi-tenant, hosted, 9-layer evidence bundles.	`actenon-kernel`, `actenon-permit`
`actenon-scan`	The independent scanner. Finds the execution gap in any codebase. Zero dependencies.	nothing
`sdk-go`	Go verifier SDK. Protected-endpoint proof verification in Go HTTP services.
`sdk-rust`	Rust verifier SDK. Protected-endpoint proof verification in systems components.

How to choose where to start

If you are...	Start here	Why
An engineer evaluating Actenon for the first time	`actenon-permit`	The on-ramp. `Actenon.local()` gives you the full feature set in-process — no Cloud, no login.
A security reviewer or auditor	`actenon-kernel`	The trust anchor. 51 conformance vectors, public threat model, audit responses.
A platform team deciding on a wire format	`actenon-protocol`	The neutral contract. Zero dependencies. Any language, any framework, any cloud.
A DevSecOps engineer who wants CI integration today	`actenon-scan`	Zero-dependency scanner with a GitHub Action that emits SARIF to the Security tab.
A platform team that wants a hosted control plane	`actenon-cloud`	Multi-tenant, 9-layer evidence bundles, insurer-facing clarity. Optional — everything else runs without it.

Multi-language SDKs

Language	Package	Use case
Python	`pip install actenon-permit` · `pip install actenon-kernel` · `pip install actenon-protocol` · `pip install actenon-scan` (all on PyPI)	Reference implementation. Full kernel: minter, verifier, executor, CLI, conformance.
TypeScript	`npm install @actenon/sdk` (v1.4.0) · `npm install @actenon/protocol-types` (v1.3.0)	Discriminated result types, receipt verification, protocol parity with Python.
Go	`go get github.com/actenon/sdk-go@v1.0.0`	Verifier-edge proof checking in Go HTTP services.
Rust	`cargo add --git https://github.com/Actenon/sdk-rust` (crates.io pending)	Verifier-edge proof checking in systems components.

Every SDK runs against the same 51 conformance vectors in the Kernel. Conformance, not pedigree, decides validity.

Principles

The execution edge is the only trustworthy trust boundary. Upstream controls matter; they are not the missing boundary.
Proof must be bound to the exact action. Action name, target, tenant, subject, audience, scope, time window, single-use nonce. Any mutation is detected at the edge.
The Kernel does not issue grants or make policy decisions. That's Permit's job. The Kernel verifies proofs at the edge and refuses on any failure.
The agent never holds the production credential. The broker resolves it server-side after verification passes.
Submission is not execution. A submitted state is non-final. succeeded requires a cryptographically verified receipt.
Cryptography proves execution integrity and authority-process integrity. It does not prove business decision correctness. We are honest about which is which.
Every repo is independently adoptable. The Kernel runs without Permit, Cloud, or Scan. Scan runs without anything. Protocol runs without anything. Cloud is optional. Permit runs without Cloud.
Conformance, not pedigree. A third-party proof that conforms to the Kernel's conformance vectors will be accepted by the Kernel verifier, regardless of who issued it.
Vendor-neutral by design. Scan recognises 30+ non-Actenon guard patterns. The Protocol is implementable by any vendor. Cloud is optional. No lock-in.
Source-disciplined incident reconstruction. Pattern language only. No uncited facts about named incidents.
Claims are machine-verified. Every repo carries a claims: machine-verified badge linking to a CI gate that fails if any factual README claim — dependency counts, conformance counts, install commands, readiness ratings — stops being true. How it works.

License

The four open components — Protocol, Kernel, Permit and Scan — are Apache-2.0. actenon-cloud is source-available; see its LICENSE.