Permguard
PERMGUARD

Authorization & Trust for the Agentic Era

The security overlay for the agentic era.

Permguard provides traditional application authorization through Policy Decision Points, together with a security overlay for the agentic era.

Discover PermguardScroll to explore

Trust-anchored protocol

Trust anchors shape an enforceable execution path.

Identity enters a protected execution tunnel. Trust anchors operate inside it, its boundaries enforce the guardrails, and the protocol at its exit constrains the final decision.

Permguard Admin Preview

The Control Plane, administered.

The desktop app for the people who run Permguard. Connect your control planes and manage them from one window: the server that hosts them, the ledgers and policies they serve, the events and decisions they record.

Products / 03

Three Products. One Mission.

Trust, authorization, and isolated execution—one system for governing agents, applications, and services.

03 ProductsOne authorization foundation
01 · Trust

Agentic Trust Fabric

The security overlay for the agentic ecosystem. Secure agents, tools, and agent-to-agent interactions with Provenance Identity Continuity (PIC) and the Permguard Trust Plane.

  • PIC
  • Trust Plane
  • MCP/A2A
  • Agent Security
Explore Trust Fabric
02 · Authorization

Policy Decision Point

Authorization for services and applications. A Policy Decision Point designed for enterprise applications and built for Zero Trust, resilience, full auditability, and distributed systems.

  • Policies
  • PDP
  • Edge Enforcement
  • Audit
Explore PDP
Image03 · Execution

Soglia

AI agents, sandboxed. Every agent invocation runs in a fresh, isolated Soglia execution. Its actions cross Soglia guardrails before they can reach the outside world, and the execution is destroyed when it ends.

  • Isolated execution
  • Guardrails
  • Ephemeral
Explore Soglia

Policies / Cedar · Rego · Dogwood

Write the policy. In the language that fits it.

A ledger keeps its policies in partitions, each in its own language: Cedar for who may do what, Rego for the rules of an API, Dogwood when the answer depends on what happened before. These are real policies of the Atlas Commerce playground.

orders.cedarpartition order-operations
// Customer-support staff can inspect orders only inside their merchant.@alias("merchant-support-readers")permit (    principal in Role::"support-agents",    action == Action::"view",    resource) when {    principal.merchant == resource.merchant};
CedarSupport agents see an order only when it belongs to their own merchant.

Command line / permguard

Policies as code. Shipped from your terminal.

Create a ledger, plan and apply policies, read the signed objects behind them, ask for a decision: the same CLI, one workflow.

$

Catalog

$

Author & publish

$

Objects & decisions

SDKs / your application

Integrate it in your app. In minutes.

With the official SDKs, authorization leaves your code: no more roles and rules hard-wired in every service, one call asks Permguard for the decision. Drag the handle to see the difference.

Imagedocuments.go
Before · in your code
// Who may read a document, decided in the application.func canRead(user User, doc Document) bool {	roles, err := db.RolesOf(user.ID)	if err != nil {		return false	}	for _, role := range roles {		if role == "admin" {			return true		}		if role == "editor" && doc.Team == user.Team {			return true		}	}	return doc.Owner == user.ID}if !canRead(user, doc) {	return ErrForbidden}
After · with Permguard
// The decision comes from Permguard.client, err := permguard.NewClient("grpc://localhost:7443")if err != nil {	return err}defer client.Close()response, err := client.Evaluate(ctx, &permguard.EvaluateRequest{	Zone:     "acme",	Ledger:   "documents",	Subject:  &permguard.Entity{Type: "user", ID: user.ID},	Resource: &permguard.Entity{Type: "document", ID: doc.ID},	Action:   &permguard.Action{Name: "read"},})if err != nil || !response.Decision {	return ErrForbidden}

Decision logs / evidence

Every decision, on record. Into your pipelines.

Every answer becomes a record, chained to the one before and shipped in signed batches. Read it from your own offset, with the CLI or the API, as many readers as you need: your SIEM, your threat detection, your data lake. Identities stay pseudonymised unless you name what to keep in clear.

pipelinesread once, route everywhere

Decision log

commerce/order-platform

one writer · signed batches

Your consumer · example

a collector, a stream processor, your own service

  1. ReadGET …/records?from=the decision log API, HTTP or gRPC, from its own offset
  2. Verifyproof=truechain and signatures, against the data plane's keys
  3. Shapeyour schemaone event per decision, as your SIEM expects it
  4. Routeby outcomeevery decision to the SIEM and the lake, denials to threat detection too

its own offset · seq 1851

SIEMevery decision, in near real timereceived · 10
Threat detectionevery refusal: denials are never sampledreceived · 3
Data lakeevery decision, one file a dayreceived · 6

The same consumer, with the CLI · route-decisions.sh

permguard decisions tail --zone commerce --ledger order-platform \    --follow --verify --keys data-plane-keys.json -o json \  | jq -c '.decisions[] | {time: .at, user: .subject, action, resource, outcome}' \  | while read -r event; do      curl -s -X POST "$SIEM_URL" -d "$event"      case "$(jq -r .outcome <<< "$event")" in        deny|deny_by_default) curl -s -X POST "$THREAT_URL" -d "$event" ;;      esac      echo "$event" >> "lake/$(date +%F).jsonl"    done

Routed

1842 permit → SIEM · data lake

1843 permit → SIEM · data lake

1844 deny → SIEM · threat detection · data lake

1845 permit → SIEM · data lake

1846 permit → SIEM · data lake

1847 deny → SIEM · threat detection · data lake

1848 permit → SIEM · data lake

1849 permit → SIEM · data lake

1850 permit → SIEM · data lake

1851 deny → SIEM · threat detection · data lake

PipelinesThe control plane keeps no reader's position: a pipeline holds its own offset, so many can read side by side, none slows the others, and one that stops resumes where it left off.

Learn / Watch

Learn with Permguard. Watch in your language.

Explore practical training videos about Permguard, AI agents, authorization, and secure autonomous systems. Available in English, Italian, and Spanish.

All playlists on YouTube
03 PlaylistsEnglish · Italiano · Español

Philosophy

If it cannot be proven, it does not ship.

Permguard is built on the principles of Provenance Identity Continuity (PIC): formal model first. A mechanism enters Permguard only when the property it enforces can be stated and proved. Whatever cannot be proved stays out, however convenient it would be.

  1. 01Statedevery guarantee is a formal property, not a promise
  2. 02Provedit holds along the whole causal chain of an execution
  3. 03EnforcedPermguard supplies exactly what the proof assumes
  • IEEE NCA 2026
  • Peer-reviewed
  • Machine-checked in Lean 4

The confused deputy, proved impossible.

“Authority Continuity for Verifiable Lineage in Distributed Systems and AI Agents” — to be presented at the 24th IEEE International Symposium on Network Computing and Applications, November 10–13, 2026, Syracuse, Italy.

PoP view · Possession

PoP proves control of the token. It cannot see which execution is using it or where that use sits in causal time.

PIC view · Continuity

PIC adds lineage. The same operation, resource, and token become two distinguishable executions.

6
theorems
Lean 4
machine-checked
≈64 µs
per hop, reference implementation

Model-level results, under the assumptions stated in the paper.

Explore PIC Protocol
ResultsLean 4

Theorem 6 · Exclusion

The confused deputy

Authority only narrows along a lineage, never expands. A privilege absent at the origin cannot appear at any later hop, so a request can no longer borrow a deputy's own authority: the confused deputy is not a state a valid PIC execution can represent.

(o, r) ∉ C0 ⟹ (o, r) ∉ Cn

Theorems 3 – 4 · Lineage

The temporal confused deputy

Same principal, same token, same privilege, different lineage: spatially valid, temporally invalid. Possession-only authorization provably cannot tell the two apart, and any policy that does must read the lineage. PIC puts it in the decision.

e = (o, r, ℓ) ∈ O × R × L

Platform / Governance

One Platform. Unified Governance.

One governance model between the Agentic Trust Fabric and the Policy Decision Point: together, they establish trust, enforce authorization, and ensure authority continuity across agents, applications, and services.

  • Applications
  • APIs & Services
  • AI Agents
  • MCP / A2A
Trust fabric Live
ImageAuthority core

Agentic Trust Fabric

Distributed authority router

  • Security Overlay
  • PIC / Trust Plane

Permguard Trust Plane

  • Databases
  • AI Agents
  • MCP / A2A Endpoints
  • Cloud / On-Prem

All traffic is secured by the Agentic Trust Fabric. Destinations enforce authorization locally using the Policy Decision Point.

Applications, APIs & services, AI agents, and MCP / A2A all connect through the Permguard Agentic Trust Fabric — providing the Security Overlay and the PIC / Trust Plane — which in turn reaches databases, AI agents, MCP / A2A endpoints, and cloud or on-prem destinations. All traffic is secured by the Agentic Trust Fabric; destinations enforce authorization locally using the Policy Decision Point.
04 PrinciplesZero Trust · Agentic · Distributed · Auditable
  • 01

    Zero Trust by Design

    Enforce least privilege and continuous verification.

  • 02

    Agentic Ready

    Purpose-built for agents, tools, and agent-to-agent flows.

  • 03

    Distributed & Scalable

    Built for performance at the edge and across distributed systems.

  • 04

    Full Auditability

    Every decision and action is logged and verifiable.

AI agents / Transport

AI agents have autonomy and communicate in every way. They are not locked inside a perimeter.

Permguard's security overlay enables real autonomous and distributed agents.

02 LayersAny transport · any framework

01 · TRANSPORT

Agents communicate in every way.

AI agents need both synchronous and asynchronous communication across workflows, events, messaging, gRPC, and HTTP.As microservices taught us, distributed systems must tolerate failure while preserving authority continuity across every hop.

PERMGUARD / SECURITY OVERLAYLIVE ROUTINGAUTHORITY CONTINUITYVERIFY · ROUTE · RECORDACTIVE01WORKFLOW02EVENT03MESSAGE04gRPC05HTTPANY TRANSPORTONE VERIFIED AUTHORITY

The Permguard Security Overlay applied agnostically at the transport layer.

02 · FRAMEWORKS

Bring your agent framework. Keep your stack.

Every interaction runs through a governed, isolated execution.LangChain, Google ADK, Microsoft Agent Framework, Strands, and custom agents run inside a secure execution sandbox connected to the Agentic Trust Fabric.

FRAMEWORK ADAPTER MESHAGENT SECURITYAGENTIC TRUST FABRICAI AGENT SECURITY LAYER · PICLIVESOGLIA / SECURE EXECUTION SANDBOXISOLATED · EPHEMERALLangChainGoogle ADKMicrosoft Agent FrameworkStrandsYour own codeANY AGENT FRAMEWORKONE SECURITY LAYER

Agents communicate securely inside an isolated Soglia execution sandbox.