Skip to content
Back to search

docker

Govern consequential AI agent actions in Docker with deterministic policy, human approval, and signed Decision Dossiers.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/decionis--docker/badge.svg)](/listings/decionis--docker)

HTML

<a href="/listings/decionis--docker"><img src="/api/listings/decionis--docker/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 349 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Decionis for Docker
  2. <!-- Badge sweep 2026-08-18: every URL below verified HTTP 200 (rules/discovery.rules.md Rule 1.1),
  3. with two branch-lifecycle caveats that resolve at merge: the actions.yml badge endpoint
  4. registers when the workflow reaches the default branch (this README publishes in the same
  5. merge), and coverage populates on the first master CI run after the codecov upload landed. -->
  6. [![CI](https://github.com/decionis/docker/actions/workflows/actions.yml/badge.svg)](https://github.com/decionis/docker/actions/workflows/actions.yml)
  7. [![License](https://img.shields.io/github/license/decionis/docker)](https://github.com/decionis/docker/blob/master/LICENSE)
  8. [![Go Report Card](https://goreportcard.com/badge/github.com/decionis/docker)](https://goreportcard.com/report/github.com/decionis/docker)
  9. [![Coverage](https://codecov.io/gh/decionis/docker/graph/badge.svg)](https://codecov.io/gh/decionis/docker)
  10. [![Go version](https://img.shields.io/github/go-mod/go-version/decionis/docker)](https://github.com/decionis/docker/blob/master/go.mod)
  11. [![Release](https://img.shields.io/github/v/release/decionis/docker)](https://github.com/decionis/docker/releases)
  12. [![decionis/mcp pulls](https://img.shields.io/docker/pulls/decionis/mcp?label=decionis%2Fmcp%20pulls&logo=docker)](https://hub.docker.com/r/decionis/mcp)
  13. [![desktop-extension pulls](https://img.shields.io/docker/pulls/decionis/desktop-extension?label=desktop-extension%20pulls&logo=docker)](https://hub.docker.com/r/decionis/desktop-extension)
  14. **Deterministic execution authority for AI agents and automated workflows running with Docker.**
  15. Decionis adds an explicit authority boundary between an AI agent's intent and consequential execution.
  16. 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**.
  17. The result is an explicit decision:
  18. **PROCEED · HOLD · BLOCK**
  19. When policy requires human authority, **Decionis Presence** can request cryptographically verifiable human approval before execution continues.
  20. Every governed decision can produce a signed **Decision Dossier** containing the policy, evidence, reason codes, evaluation metadata, and cryptographic proof behind the decision.
  21. ---
  22. ## Why Decionis for Docker?
  23. AI coding agents increasingly operate inside containers, development environments, CI/CD pipelines, and MCP-connected toolchains.
  24. They can write code.
  25. They can also:
  26. ```text
  27. terraform apply
  28. npm publish
  29. git push --force
  30. docker run --privileged
  31. database.drop
  32. github.create_release
  33. ```
  34. The question is no longer only:
  35. > **Can the agent execute this tool?**
  36. It is:
  37. > **Is the agent authorized to execute this action, under this policy, in this context, right now?**
  38. Decionis provides that authority layer.
  39. ```text
  40. AI Agent / Automation
  41. │
  42. │ proposes action
  43. ▼
  44. ┌──────────────────────┐
  45. │ DECIONIS │
  46. │ Execution Authority │
  47. │ │
  48. │ deterministic policy │
  49. └──────────┬───────────┘
  50. │
  51. ┌──────┼──────┐
  52. │ │ │
  53. PROCEED HOLD BLOCK
  54. │ │
  55. │ ▼
  56. │ PRESENCE
  57. │ Human Authority
  58. │ │
  59. │ verified
  60. │ │
  61. └──────┴───────────► Execute
  62. │
  63. ▼
  64. Decision Dossier
  65. ```
  66. ## What this repository provides
  67. `decionis/docker` is the open integration surface for running and experiencing Decionis in Docker-based developer environments.
  68. The project is designed to include:
  69. ### Decionis MCP Server
  70. Run **Decionis Execution Authority** as a containerized MCP service for compatible agent environments and MCP clients.
  71. Agents can request deterministic authorization before consequential tool execution and retrieve the resulting Decision Dossier.
  72. ### Docker Desktop Extension
  73. A native Docker Desktop experience for observing governed agent activity.
  74. The extension is designed to surface:
  75. - live execution-authority decisions
  76. - PROCEED, HOLD, and BLOCK outcomes
  77. - policy and reason codes
  78. - pending Presence approvals
  79. - policy drift and overrides
  80. - signed Decision Dossiers
  81. ### Presence approval
  82. A `HOLD` decision can require human authority before an agent continues.
  83. Presence provides action-bound human verification using supported mechanisms such as passkeys and trusted-device approval.
  84. ```text
  85. Agent requests production deployment
  86. │
  87. ▼
  88. Decionis
  89. │
  90. HOLD
  91. │
  92. ▼
  93. Presence
  94. │
  95. Human approval
  96. │
  97. ▼
  98. PROCEED
  99. │
  100. ▼
  101. Execute
  102. ```
  103. The agent does not decide whether human approval is necessary.
  104. **Policy does.**
  105. ### Dev Container governance
  106. Decionis can be incorporated into Dev Container environments so execution governance travels with the development environment.
  107. This enables teams to establish authority boundaries for AI-assisted development without relying on every developer or agent to implement governance independently.
  108. ### Containerized execution gates
  109. For agent architectures requiring an execution boundary, Decionis components can sit between an agent and consequential tools or APIs.
  110. The goal is not generic network filtering.
  111. 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.
  112. ---
  113. ## Example
  114. An AI coding agent decides that a production infrastructure change is required:
  115. ```text
  116. Action: terraform.apply
  117. Environment: production
  118. Requested by: AI coding agent
  119. Risk: HIGH
  120. ```
  121. Before the operation executes, Decionis evaluates it:
  122. ```text
  123. Verdict: HOLD
  124. Policy: production-infrastructure-v12
  125. Reason:
  126. Human authorization required for
  127. production infrastructure changes.
  128. ```
  129. Presence requests approval from an authorized human.
  130. After successful verification:
  131. ```text
  132. Presence: VERIFIED
  133. Verdict: PROCEED
  134. Dossier: dos_...
  135. Evidence: SIGNED
  136. Algorithm: Ed25519
  137. ```
  138. Only then can the downstream system continue execution.
  139. ---
  140. ## Architecture
  141. Decionis deliberately separates **intent, authority, human approval, and execution**.
  142. ```text
  143. ┌──────────────────────────────────────────┐
  144. │ AI AGENT │
  145. │ Claude · Cursor · VS Code · Custom │
  146. └────────────────────┬─────────────────────┘
  147. │
  148. ▼
  149. ┌──────────────────────────────────────────┐
  150. │ TOOL / MCP LAYER │
  151. │ MCP · CLI · SDK · Agent Runtime │
  152. └────────────────────┬─────────────────────┘
  153. │
  154. ▼
  155. ┌──────────────────────────────────────────┐
  156. │ DECIONIS │
  157. │ │
  158. │ Deterministic Authority │
  159. │ │
  160. │ Policy · Context · Risk · Evidence │
  161. └────────────────────┬─────────────────────┘
  162. │
  163. HOLD │
  164. ▼
  165. ┌──────────────────────────────────────────┐
  166. │ PRESENCE │
  167. │ │
  168. │ Human Authority │
  169. │ │
  170. │ Passkey · Device · Verified Approval │
  171. └────────────────────┬─────────────────────┘
  172. │
  173. ▼
  174. ┌──────────────────────────────────────────┐
  175. │ EXECUTION │
  176. │ │
  177. │ GitHub · AWS · DB · Terraform · APIs │
  178. └────────────────────┬─────────────────────┘
  179. │
  180. ▼
  181. DECISION DOSSIER
  182. ```
  183. ## Decionis does not execute the action
  184. Decionis is an **execution-authorization control plane**.
  185. It evaluates proposed actions and returns an authority decision. It does not execute payments, deployments, database operations, trades, infrastructure changes, or other downstream actions.
  186. Connected agents and systems remain responsible for execution.
  187. This separation allows Decionis to govern consequential execution without becoming the system performing it.
  188. ---
  189. ## Decision Dossiers
  190. A governed action can produce an immutable Decision Dossier containing evidence such as:
  191. ```text
  192. Decision
  193. Evaluation ID
  194. Decision type
  195. Verdict
  196. Reason codes
  197. Policy version
  198. Execution context
  199. Presence verification
  200. Evidence hash
  201. Signature
  202. Timestamp
  203. ```
  204. Dossiers are cryptographically signed using Ed25519 and can be independently verified.
  205. This turns:
  206. > "The agent was allowed to do it."
  207. into:
  208. > **"Here is cryptographic evidence showing exactly why execution was authorized."**
  209. ---
  210. ## Use cases
  211. Decionis for Docker is intended for consequential agent and automation workflows including:
  212. - production deployments
  213. - infrastructure changes
  214. - privileged MCP tool execution
  215. - database mutations
  216. - package publishing
  217. - release creation
  218. - CI/CD operations
  219. - cloud administration
  220. - financial and enterprise API operations
  221. - autonomous agent workflows
  222. ---
  223. ## Project status
  224. This repository contains the Docker integration surface for Decionis.
  225. Components will be released incrementally as the Docker developer experience evolves.
  226. The initial focus is:
  227. 1. containerized Decionis MCP execution authority
  228. 2. Docker Desktop visibility into authority decisions
  229. 3. Presence approval for held actions
  230. 4. signed Decision Dossier inspection
  231. 5. Dev Container integration
  232. ---
  233. ## Security
  234. Decionis is designed around a simple principle:
  235. **An AI agent's ability to call a tool is not the same as authority to execute the action.**
  236. Sensitive execution should cross an explicit, inspectable authority boundary.
  237. If you discover a security issue, please follow the security reporting process described in `SECURITY.md` rather than opening a public issue.
  238. ---
  239. ## Contributing
  240. Issues, integration examples, documentation improvements, and contributions to the Docker integration layer are welcome.
  241. The Docker integration surface is intentionally separated from Decionis's hosted control-plane implementation.
  242. See `CONTRIBUTING.md` for contribution guidelines.
  243. ---
  244. ## License
  245. See `LICENSE` for licensing terms.
  246. ---
  247. **Decionis for Docker**
  248. *Your agents have tools. Decionis decides when they can use them.*%

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.