Decionis for Docker adds an authority layer between an agent’s request and a consequential Docker action. It checks the proposed action against versioned policy, can hold execution for Presence approval, and can produce a signed Decision Dossier.
Builders who want their Docker-based agents to ask for approval before they deploy, publish, mutate data, or call privileged tools.
You can govern sensitive agent actions with deterministic policy and human approval before anything executes.
Evaluates proposed actions against versioned policy before execution and returns PROCEED, HOLD, or BLOCK.
Can request verified human approval when policy says a held action needs it.
Produces an auditable dossier with policy, evidence, reason codes, metadata, and an Ed25519 signature.
Runs Decionis as a containerized MCP service so agent environments can request authorization before tool use.
Surfaces live authority decisions, pending approvals, policy drift, and signed dossiers in Docker Desktop.
Lets governance travel with the development environment instead of being re-implemented by each agent or developer.
terraform apply npm publish git push --force docker run --privileged database.drop github.create_release
Action: terraform.apply Environment: production Requested by: AI coding agent Risk: HIGH
Verdict: HOLD Policy: production-infrastructure-v12 Reason: Human authorization required for production infrastructure changes.
Presence: VERIFIED Verdict: PROCEED Dossier: dos_... Evidence: SIGNED Algorithm: Ed25519
Deterministic execution authority for AI agents and automated workflows running with Docker.
Decionis adds an explicit authority boundary between an AI agent's intent and consequential execution.
When an agent attempts a sensitive action—such as deploying infrastructure, modifying production data, publishing a package, invoking a privileged MCP tool, or performing another governed operation—Decionis evaluates the proposed action against deterministic, versioned policy before execution.
The result is an explicit decision:
PROCEED · HOLD · BLOCK
When policy requires human authority, Decionis Presence can request cryptographically verifiable human approval before execution continues.
Every governed decision can produce a signed Decision Dossier containing the policy, evidence, reason codes, evaluation metadata, and cryptographic proof behind the decision.
AI coding agents increasingly operate inside containers, development environments, CI/CD pipelines, and MCP-connected toolchains.
They can write code.
They can also:
terraform apply
npm publish
git push --force
docker run --privileged
database.drop
github.create_release
The question is no longer only:
Can the agent execute this tool?
It is:
Is the agent authorized to execute this action, under this policy, in this context, right now?
Decionis provides that authority layer.
AI Agent / Automation
│
│ proposes action
▼
┌──────────────────────┐
│ DECIONIS │
│ Execution Authority │
│ │
│ deterministic policy │
└──────────┬───────────┘
│
┌──────┼──────┐
│ │ │
PROCEED HOLD BLOCK
│ │
│ ▼
│ PRESENCE
│ Human Authority
│ │
│ verified
│ │
└──────┴───────────► Execute
│
▼
Decision Dossier
decionis/docker is the open integration surface for running and experiencing Decionis in Docker-based developer environments.
The project is designed to include:
Run Decionis Execution Authority as a containerized MCP service for compatible agent environments and MCP clients.
Agents can request deterministic authorization before consequential tool execution and retrieve the resulting Decision Dossier.
A native Docker Desktop experience for observing governed agent activity.
The extension is designed to surface:
A HOLD decision can require human authority before an agent continues.
Presence provides action-bound human verification using supported mechanisms such as passkeys and trusted-device approval.
Agent requests production deployment
│
▼
Decionis
│
HOLD
│
▼
Presence
│
Human approval
│
▼
PROCEED
│
▼
Execute
The agent does not decide whether human approval is necessary.
Policy does.
Decionis can be incorporated into Dev Container environments so execution governance travels with the development environment.
This enables teams to establish authority boundaries for AI-assisted development without relying on every developer or agent to implement governance independently.
For agent architectures requiring an execution boundary, Decionis components can sit between an agent and consequential tools or APIs.
The goal is not generic network filtering.
Decionis evaluates the meaning of the proposed action—who or what requested it, what it intends to do, its risk and business context, and which policy governs execution.
An AI coding agent decides that a production infrastructure change is required:
Action: terraform.apply
Environment: production
Requested by: AI coding agent
Risk: HIGH
Before the operation executes, Decionis evaluates it:
Verdict: HOLD
Policy: production-infrastructure-v12
Reason:
Human authorization required for
production infrastructure changes.
Presence requests approval from an authorized human.
After successful verification:
Presence: VERIFIED
Verdict: PROCEED
Dossier: dos_...
Evidence: SIGNED
Algorithm: Ed25519
Only then can the downstream system continue execution.
Decionis deliberately separates intent, authority, human approval, and execution.
┌──────────────────────────────────────────┐
│ AI AGENT │
│ Claude · Cursor · VS Code · Custom │
└────────────────────┬─────────────────────┘
│
▼
┌──────────────────────────────────────────┐
│ TOOL / MCP LAYER │
│ MCP · CLI · SDK · Agent Runtime │
└────────────────────┬─────────────────────┘
│
▼
┌──────────────────────────────────────────┐
│ DECIONIS │
│ │
│ Deterministic Authority │
│ │
│ Policy · Context · Risk · Evidence │
└────────────────────┬─────────────────────┘
│
HOLD │
▼
┌──────────────────────────────────────────┐
│ PRESENCE │
│ │
│ Human Authority │
│ │
│ Passkey · Device · Verified Approval │
└────────────────────┬─────────────────────┘
│
▼
┌──────────────────────────────────────────┐
│ EXECUTION │
│ │
│ GitHub · AWS · DB · Terraform · APIs │
└────────────────────┬─────────────────────┘
│
▼
DECISION DOSSIER
Decionis is an execution-authorization control plane.
It evaluates proposed actions and returns an authority decision. It does not execute payments, deployments, database operations, trades, infrastructure changes, or other downstream actions.
Connected agents and systems remain responsible for execution.
This separation allows Decionis to govern consequential execution without becoming the system performing it.
A governed action can produce an immutable Decision Dossier containing evidence such as:
Decision
Evaluation ID
Decision type
Verdict
Reason codes
Policy version
Execution context
Presence verification
Evidence hash
Signature
Timestamp
Dossiers are cryptographically signed using Ed25519 and can be independently verified.
This turns:
"The agent was allowed to do it."
into:
"Here is cryptographic evidence showing exactly why execution was authorized."
Decionis for Docker is intended for consequential agent and automation workflows including:
This repository contains the Docker integration surface for Decionis.
Components will be released incrementally as the Docker developer experience evolves.
The initial focus is:
Decionis is designed around a simple principle:
An AI agent's ability to call a tool is not the same as authority to execute the action.
Sensitive execution should cross an explicit, inspectable authority boundary.
If you discover a security issue, please follow the security reporting process described in SECURITY.md rather than opening a public issue.
Issues, integration examples, documentation improvements, and contributions to the Docker integration layer are welcome.
The Docker integration surface is intentionally separated from Decionis's hosted control-plane implementation.
See CONTRIBUTING.md for contribution guidelines.
See LICENSE for licensing terms.
Decionis for Docker
Your agents have tools. Decionis decides when they can use them.%
Sign in to join the discussion.
No comments yet. Be the first to say what this is good for.
Stop your AI from making things up — it proposes, deterministic tools decide, every claim checked against ground truth with evidence. Grounded facts and context survive resets. Reverse engineering is the proving ground. MCP server + CLI.
20 MB lightweight cross-platform database client for 90+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具，支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 90+ 数据库，提供桌面端、Docker、CLI、内置 AI 助手和 MCP Server。
x64dbg-MCP Server is a native MCP (Model Context Protocol) plugin for x64dbg that exposes the debugger's full functionality over HTTP. Connect any MCP-compatible AI assistant and control x64dbg programmatically: set breakpoints, step through code, read memory, dump registers, and more. Built with Zig — zero dependencies, single-binary output, cros
A MCP for Claude Desktop / Claude Code / Windsurf / Cursor to build n8n workflows for you
HexStrike AI MCP Agents is an advanced MCP server that lets AI agents (Claude, GPT, Copilot, etc.) autonomously run 150+ cybersecurity tools for automated pentesting, vulnerability discovery, bug bounty automation, and security research. Seamlessly bridge LLMs with real-world offensive security capabilities.
Unity MCP acts as a bridge between AI assistants and your Unity Editor. Give your LLM tools to manage assets, control scenes, edit scripts, and automate tasks within Unity.