Skip to content
Back to search

agentfox

MarketplaceWorks with Claude CodeGitHub

AgentFox control plane — agent governance, guardrails, audit and compliance for AI agents in production.

Safety scan

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

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/architsharm--agentfox/badge.svg)](/listings/architsharm--agentfox)

HTML

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

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Python 3.11 or newer.

Attack your own agent (about three minutes)

1. [Sign in](https://useagentfox.com/login); signing in creates your workspace. Press **Create a key**. 2. In your agent's repository, with its dependencies installed, run the command the page shows:

   pip install -U agentfox
   agentfox init --key nom_api_… --server https://…

`init` reads your code without running it and reports the agents and tools it found. Leave it running: the attack test runs your agent on your machine, with every tool faked so nothing real happens. 3. Press **Add N agents to AgentFox**. The attack test starts by itself and shows, per kind of attack, how many got through. 4. Press **Turn on basic guardrails and test again**. Basic guardrails go on and the same attacks run again, so you see the before and after side by side, including how many normal requests were still answered. 5. Add the one line `init` prints (`agentfox.auto("<agent>")`) and run your app. Its calls show up on the agent's **Activity** tab.

From the command line only

pip install agentfox
agentfox scan                    # names every agent it found, ends with: agentfox up
agentfox up                      # registers them, declares their tools, adds agentfox.auto()
python main.py                   # run your app as usual
agentfox findings                # what it saw, and what it would have stopped
agentfox test redteam <agent>    # attack-test it

`up` uses the names the code gives your agents, the same names `scan` printed, and adds `agentfox.auto("<agent>")` to the file that starts one (a `pyproject.toml` script, the graph `langgraph.json` loads, or the file that runs it, `src/` included), for Python apps on LangGraph, LangChain, CrewAI, AutoGen, pydantic-ai and the OpenAI Agents SDK. The name is the agent that file runs (a crew or swarm takes its project's name), shown before anything changes so you can edit it. In a folder of separate examples it sets up one, with only that agent's tools, and says how to pick another (`agentfox up --agent <name>`); in a monorepo that edits the picked agent's own app, and `scan`, `up`, `init` and `auto()` all name one agent the same way (`FinancialPlannerAgent` is `financial-planner-agent` everywhere). `auto()` also governs Google ADK (its google-genai model calls and function calls) and smolagents (its huggingface_hub model calls, and each tool where it runs). It starts in watch mode: every library records what it would have stopped and stops nothing (destructive commands such as `rm -rf ~/` and tampering with AgentFox aside). Turn blocking on one library at a time when its decisions look right: `agentfox policy enforce tool-containment` for tool calls, `agentfox policy enforce baseline` for prompt attacks, personal data and secrets. `up` changes nothing else by default: coding-agent hooks, the GitHub workflow and the local API are `--with coding-agents`, `--with ci` and `--with view`. Everything stays on your machine; a pip install has no web dashboard (`agentfox findings` is the terminal view), which comes with AgentFox Cloud or the self-hosted stack.

The prompt-injection classifier (PIGuard) is an extra, not part of `pip install agentfox`:

pip install 'agentfox[classifiers]'
agentfox admin detectors pull injection.classifier   # downloads the model weights once

Without it, injection checks use the pattern-based detector only, alongside the PII, secrets and hidden-Unicode checks and tool containment, all of which work on a plain install. `agentfox doctor` says which detectors run on your machine, and `auto()` says once that the classifier is skipped rather than on every run. The Docker image ships the extra and the weights.

One key everywhere

export AGENTFOX_URL=https://…
export AGENTFOX_API_KEY=nom_api_…

Or run `agentfox login`, which checks the key and saves both in `.agentfox/agentfox.env`

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.

.claude-plugin/marketplace.json · Manifest · 15 lines
  1. {
  2. "name": "agentfox",
  3. "description": "AgentFox control plane \u2014 agent governance, guardrails, audit and compliance for AI agents in production.",
  4. "owner": {
  5. "name": "Nometria Inc"
  6. },
  7. "plugins": [
  8. {
  9. "name": "agentfox",
  10. "source": "./plugins/claude-code",
  11. "description": "Operator plugin for the AgentFox control plane (skills, commands, subagents, safety hooks).",
  12. "version": "0.1.0"
  13. }
  14. ]
  15. }
README.md · README · 331 lines · 3 findings marked
  1. <!-- mcp-name: io.github.architsharm/agentfox -->
  2. <div align="center">
  3. <img src="https://raw.githubusercontent.com/architsharm/agentfox/main/docs/assets/mark.webp" width="72" alt="" />
  4. # AgentFox
  5. **Find, govern and protect every AI agent you run.**
  6. **Guardrails that don't block your real customers.**
  7. Open source. Attack-test your own agent in about three minutes, then watch the same attacks
  8. get stopped. Works with the OpenAI Agents SDK, LangGraph, LangChain, CrewAI, AutoGen,
  9. OpenAI, Anthropic, LiteLLM, MCP servers, Claude Code and Codex.
  10. [![CI](https://github.com/architsharm/agentfox/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/architsharm/agentfox/actions/workflows/ci.yml) [![Licence](https://img.shields.io/badge/licence-Apache--2.0-2f6feb.svg)](https://github.com/architsharm/agentfox/blob/main/LICENSE) [![Python](https://img.shields.io/badge/python-3.11%2B-2f6feb.svg)](https://github.com/architsharm/agentfox/blob/main/pyproject.toml) [![PyPI](https://img.shields.io/pypi/v/agentfox.svg?color=2f6feb)](https://pypi.org/project/agentfox/) [![Playground](https://img.shields.io/badge/playground-no%20account-c23600.svg)](https://useagentfox.com/playground)
  11. **[▶ Try it in the browser, no account](https://useagentfox.com/playground)** &nbsp;·&nbsp; [Docs](https://useagentfox.com/docs) &nbsp;·&nbsp; [Benchmarks](https://useagentfox.com/benchmark) &nbsp;·&nbsp; [Discussions](https://github.com/architsharm/agentfox/discussions)
  12. ```bash
  13. pip install agentfox && agentfox scan # reads your repo, never runs it
  14. ```
  15. On AgentDojo, **0 of 588** injection attacks got through with every detector switched off.
  16. The cost is on the same [benchmark page](https://useagentfox.com/benchmark): 24 of 97 benign tasks
  17. finished without asking a person.
  18. If AgentFox is useful to you, a ⭐ helps other people find it.
  19. </div>
  20. <br />
  21. <picture>
  22. <source media="(prefers-color-scheme: dark)" srcset="docs/assets/hero-dark.webp" />
  23. <img src="https://raw.githubusercontent.com/architsharm/agentfox/main/docs/assets/hero-light.webp" alt="Four tool calls from one agent. Three are allowed; payments.transfer is refused by capability.denied, with the reason shown." />
  24. </picture>
  25. ## What it does
  26. | | |
  27. |---|---|
  28. | **Discover** | Reads your code (never runs it) and maps every agent, the tools it can call, the MCP servers and skills it loads, and who hands work to whom. |
  29. | **Govern** | Each agent gets only the tools its own code hands it, with limits on the values it may pass (an amount cap, an allowed recipient). Anything else is refused or held for a person. |
  30. | **Protect** | Checks every model and tool call at runtime: prompt injection, instructions hidden in documents and tool results, personal data and secrets leaving in replies. Starts in watch mode, so nothing your users do is blocked until you say so. |
  31. | **Test** | Attacks your real agent with its own tools faked, shows what got through, then shows the same attacks against your guardrails. |
  32. | **Prove** | Every decision lands in a tamper-evident audit trail you can verify without trusting us. |
  33. The part that does not depend on catching the attack: a transfer whose recipient came out of a
  34. retrieved document is refused because of *where the value came from*, not because a detector
  35. recognised the payload.
  36. ## Quickstart
  37. Python 3.11 or newer.
  38. ### Attack your own agent (about three minutes)
  39. 1. [Sign in](https://useagentfox.com/login); signing in creates your workspace. Press
  40. **Create a key**.
  41. 2. In your agent's repository, with its dependencies installed, run the command the page shows:
  42. ```bash
  43. pip install -U agentfox
  44. agentfox init --key nom_api_… --server https://…
  45. ```
  46. `init` reads your code without running it and reports the agents and tools it found. Leave it
  47. running: the attack test runs your agent on your machine, with every tool faked so nothing
  48. real happens.
  49. 3. Press **Add N agents to AgentFox**. The attack test starts by itself and shows, per kind of
  50. attack, how many got through.
  51. 4. Press **Turn on basic guardrails and test again**. Basic guardrails go on and the same attacks run again, so you
  52. see the before and after side by side, including how many normal requests were still
  53. answered.
  54. 5. Add the one line `init` prints (`agentfox.auto("<agent>")`) and run your app. Its calls show
  55. up on the agent's **Activity** tab.
  56. ### From the command line only
  57. ```bash
  58. pip install agentfox
  59. agentfox scan # names every agent it found, ends with: agentfox up
  60. agentfox up # registers them, declares their tools, adds agentfox.auto()
  61. python main.py # run your app as usual
  62. agentfox findings # what it saw, and what it would have stopped
  63. agentfox test redteam <agent> # attack-test it
  64. ```
  65. `up` uses the names the code gives your agents, the same names `scan` printed, and adds
  66. `agentfox.auto("<agent>")` to the file that starts one (a `pyproject.toml` script, the graph
  67. `langgraph.json` loads, or the file that runs it, `src/` included), for Python apps on
  68. LangGraph, LangChain, CrewAI, AutoGen, pydantic-ai and the OpenAI Agents SDK. The name is the
  69. agent that file runs (a crew or swarm takes its project's name), shown before anything changes
  70. so you can edit it. In a folder of separate examples it sets up one, with only that agent's
  71. tools, and says how to pick another (`agentfox up --agent <name>`); in a monorepo that edits
  72. the picked agent's own app, and `scan`, `up`, `init` and `auto()` all name one agent the same
  73. way (`FinancialPlannerAgent` is `financial-planner-agent` everywhere). `auto()` also governs
  74. Google ADK (its google-genai model calls and function calls) and smolagents (its
  75. huggingface_hub model calls, and each tool where it runs). It starts in watch mode:
  76. every library records what it would have stopped and stops nothing (destructive commands such as
  77. `rm -rf ~/` and tampering with AgentFox aside). Turn blocking on one library at a time when its
  78. decisions look right: `agentfox policy enforce tool-containment` for tool calls,
  79. `agentfox policy enforce baseline` for prompt attacks, personal data and secrets. `up` changes
  80. nothing else by default: coding-agent hooks, the GitHub workflow and the local API are
  81. `--with coding-agents`, `--with ci` and `--with view`. Everything stays on your machine; a pip
  82. install has no web dashboard (`agentfox findings` is the terminal view), which comes with
  83. AgentFox Cloud or the self-hosted stack.
  84. The prompt-injection classifier (PIGuard) is an extra, not part of `pip install agentfox`:
  85. ```bash
  86. pip install 'agentfox[classifiers]'
  87. agentfox admin detectors pull injection.classifier # downloads the model weights once
  88. ```
  89. Without it, injection checks use the pattern-based detector only, alongside the PII, secrets
  90. and hidden-Unicode checks and tool containment, all of which work on a plain install.
  91. `agentfox doctor` says which detectors run on your machine, and `auto()` says once that the
  92. classifier is skipped rather than on every run. The Docker image ships the extra and the
  93. weights.
  94. ### One key everywhere
  95. ```bash
  96. export AGENTFOX_URL=https://…
  97. export AGENTFOX_API_KEY=nom_api_…
  98. ```
  99. Or run `agentfox login`, which checks the key and saves both in `.agentfox/agentfox.env`
  100. (as `agentfox init --key` and `agentfox up` do). With a key set, every check
  101. `agentfox.auto()` makes goes to your account's gateway and the calls appear on the
  102. dashboard, and the CLI reads and writes the same account: `findings`, `agents list`,
  103. `permit`, `declare`, `policy`, `report` and `test suites` show what the dashboard shows,
  104. and each says on its first line which it is using (`Account: https://… (workspace …)` or
  105. `Local: ~/.agentfox/agentfox.db`). `agentfox doctor` checks the server and the key. Without
  106. a key everything checks and records locally. Every OpenAI, Anthropic, LiteLLM, LangChain,
  107. google-genai and huggingface_hub call in the process is checked, and every tool call in a response is checked
  108. before your code can run it; a refused one raises `agentfox.Blocked`. Coding-agent hooks
  109. record on this machine; `AGENTFOX_LOCAL=1 agentfox findings` reads them in a project
  110. connected to an account.
  111. ### Other ways in
  112. - **Check your machine (about 2 seconds):** `agentfox scan machine` reads the MCP configs
  113. and skills that Claude Code, Cursor, Claude Desktop, VS Code, Windsurf, Gemini CLI and
  114. Codex load. Nothing is started, written or sent. Without installing:
  115. `uvx agentfox scan machine`.
  116. - **As an MCP server:** AgentFox is itself an MCP server, so any MCP client can ask the
  117. control plane questions. `agentfox mcp serve` (equivalently `agentfox serve mcp`) speaks
  118. MCP over stdio and exposes 25 read-only tools, 27 with AgentFox Enterprise installed:
  119. `agentfox_findings`, `agentfox_agents`, `agentfox_policy_simulate`, `agentfox_audit_verify`
  120. and the rest. None of them changes enforcement or stops an agent, so the server is safe to
  121. hand to any client. The implementation is
  122. [`src/agentfox/apps/mcp_server.py`](https://github.com/architsharm/agentfox/blob/main/src/agentfox/apps/mcp_server.py): JSON-RPC 2.0 over
  123. stdin/stdout on the standard library, with no MCP SDK dependency, because AgentFox has to
  124. stay installable offline with no new core requirements. In Claude Desktop, Claude Code or
  125. Cursor:
  126. ```json
  127. {
  128. "mcpServers": {
  129. "agentfox": { "command": "agentfox", "args": ["mcp", "serve"] }
  130. }
  131. }
  132. ```
  133. - **Your coding agent:** in a project where you use Claude Code or Codex,
  134. `agentfox up --with coding-agents` writes the hooks, grants the agent its built-in tools
  135. and starts in watch mode, except shapes such as `rm -rf ~/`, which are refused from the
  136. start. In a repository set up for a coding agent with no agent of its own, `agentfox up`
  137. does this by default. The hooks call AgentFox by absolute path, so they work from a
  138. virtualenv install too.
  139. - **Behind a LiteLLM proxy:** one block in the proxy's `config.yaml` checks every agent
  140. behind it ([guide](https://useagentfox.com/docs/connect/litellm)).
  141. - **Look around first:** `agentfox init && agentfox demo`. `init` creates a SQLite database
  142. and loads 44 controls and the policy packs in about a second; `demo` runs a thirteen-step
  143. walkthrough in about five, in a database of its own (`~/.agentfox/demo.db`), so your
  144. project's `agentfox findings` never shows the demo's made-up agents. Both are offline: no
  145. API key, no downloaded weights, no network egress.
  146. - **Scan this directory without installing:**
  147. `curl -fsSL https://raw.githubusercontent.com/architsharm/agentfox/main/scripts/quickscan.sh | bash`
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 181 on GitHub
  148. installs the published release into a throwaway virtualenv (`| bash -s -- --main` for the
  149. current main).
  150. - **On every pull request:** the GitHub Action annotates lethal trifectas, ungoverned model
  151. calls and poisoned skills, and fails the check on the kinds you list in `fail-on`:
  152. ```yaml
  153. - uses: actions/checkout@v4
  154. - uses: architsharm/agentfox@main
  155. with:
  156. fail-on: trifecta,skills
  157. ```
  158. ## Contain a tool call
  159. Any language can ask the gateway about one call before running it:
  160. ```bash
  161. agentfox serve # gateway + control-plane API on 127.0.0.1:8080
  162. # in a second terminal:
  163. agentfox admin users create you@example.com --token # first operator + API token, shown once
  164. export AGENTFOX_API_KEY=… # the token it printed
  165. agentfox declare tool payments.transfer --impact irreversible
  166. agentfox permit grant payments-ops payments.transfer --yes
  167. agentfox policy enforce tool-containment # watching until now: start blocking
  168. curl -s -X POST http://localhost:8080/v1/guard/tool_call \
  169. -H "Authorization: Bearer $AGENTFOX_API_KEY" -H "Content-Type: application/json" \
  170. -d '{"agent":"payments-ops","tool":"payments.transfer",
  171. "arguments":{"amount":250,"currency":"USD","to":"acct_991"},
  172. "provenance":{"to":"tool_result","amount":"user"},
  173. "intent":"refund a duplicate charge"}' | jq '{verdict, approval_id}'
  174. ```
  175. ```json
  176. { "verdict": "escalate", "approval_id": "apr_01m376q43zby33tbsp" }
  177. ```
  178. The recipient came from a tool result, so the transfer waits for a human. Flip `"to"` to
  179. `"user"` and the same call returns `allow`. Before `policy enforce`, Tool containment only
  180. watches: the same call returns `allow` with `"effective_verdict": "escalate"`, what it would
  181. have done. Once a person approves it
  182. (`agentfox permit approvals approve apr_…`), the same call with `"approval_id"` added runs, once.
  183. Pointed at `/v1` as an OpenAI or Anthropic base URL, the gateway proxies model calls too, and a held
  184. one returns HTTP 428 with its `approval_id`.
  185. LangGraph, MCP, Claude Code hooks, the SDK and the
  186. full command set are in the [website guides](https://useagentfox.com/docs) and the
  187. [product tour](https://github.com/architsharm/agentfox/blob/main/docs/product-tour.md).
  188. ## Tracking without anyone running a command
  189. A scan is a snapshot. With AgentFox Enterprise (Cloud or self-hosted), connect a GitHub repository, a hosted API's OpenAPI document or an MCP server
  190. once and AgentFox keeps re-checking it: every few hours, and on every push once the GitHub webhook
  191. is registered. What changed since the last run becomes a finding, and the finding closes itself
  192. when the condition clears. Setup and every finding type:
  193. [Keep re-checking connected sources](https://useagentfox.com/docs/discover#monitoring).
  194. ## What we measured
  195. The detector comparison behind these numbers, *No Tier Wins Everywhere*, is accepted to be presented
  196. at WAITI 2026, a workshop of ACSAC 2026, in December ([artifact](https://github.com/architsharm/waiti2026-artifact)).
  197. We do not claim adversarial robustness, and we do not believe anyone can.
  198. [*The Attacker Moves Second*](https://arxiv.org/abs/2510.09023) (Nasr, Carlini, Schulhoff et al.,
  199. 2025) reports over 90% attack success against twelve published defences once the attacker adapts.
  200. So the number we lead with does not depend on catching anything: both rows below were measured
  201. with **every detector switched off**.
  202. | Evidence | Result |
  203. |---|---|
  204. | [Containment under total detector bypass](https://github.com/architsharm/agentfox/blob/main/benchmarks/containment/README.md) | **8/8 attacks contained with zero detector signal**; 4/4 legitimate calls still allowed |
  205. | [AgentDojo, replayed end to end](https://github.com/architsharm/agentfox/blob/main/benchmarks/agentdojo/README.md): 97 user tasks and 949 attack pairs, with argument provenance inferred from the real tool outputs | **588/588 attack pairs contained** with session-level taint, but only **24/97 benign tasks (24.7% [17.2, 34.2]) run without escalating to a human**. Per-argument taint: 37/97 benign tasks, 527/588 attack pairs contained. Taking provenance from the benchmark's own labels gives 97/97 and 588/588; that is an upper bound, not a measurement |
  206. The cost is benign utility: when provenance is inferred, a legitimate action that copies a
  207. value out of a tool output looks the same as an attack, and it is escalated.
  208. **Optionally, detection gets better.** The judgment tiers are off by default; with them on,
  209. agentfox catches 160/165 of the injection payloads that defeated our own pattern detectors, at
  210. 94.7% precision against the [NotInject](https://github.com/architsharm/agentfox/blob/main/benchmarks/generalization/data/README.md) over-defense
  211. set. [What each tier is worth, and what it costs](https://github.com/architsharm/agentfox/blob/main/benchmarks/judgment/README.md).
  212. ## Where we are still improving
  213. Detection is the layer we trust least, so we publish its numbers.
  214. - The default injection stack (heuristic plus the PIGuard classifier) has a held-out recall of
  215. **68.3%**, at 100% precision ([REPORT.md](https://github.com/architsharm/agentfox/blob/main/benchmarks/REPORT.md)). It needs
  216. `agentfox[classifiers]` and the model weights, which the Docker image ships; without them the
  217. heuristic runs alone, and its held-out injection recall is **16.7%**; the startup warning and
  218. `agentfox doctor` say so.
  219. - On NotInject, 339 benign prompts built to trip keyword guardrails, the classifier flags
  220. 11.5% (39/339) at the level an enforcing policy acts on (PIGuard alone), and 41% (140/339)
  221. counting the advisory backstop hits that observe mode records.
  222. - An [adaptive attacker](https://github.com/architsharm/agentfox/blob/main/benchmarks/adaptive/README.md) that reads our verdict and retries gets
  223. **74% of the attacks we catch through within 50 attempts**, measured against the
  224. heuristic-only stack that was the default until October 2026.
  225. - The deterministic answerability classifier abstains on 57/676 contested questions; with a
  226. judgment tier that becomes 572/676, at the cost of over-refusal rising from 0.75% to 6.8%.
  227. - Against a real, independently installed `llm-guard` on indirect injection via tool output, it
  228. is more precise than us: **81.8% against our 66.7%** on the same 20 cases, though of the 10
  229. attacks among them we catch all 10 and it catches 9. That run predates October 2026, while the
  230. backstop model's hits still counted toward a block
  231. ([agent_security](https://github.com/architsharm/agentfox/blob/main/benchmarks/agent_security/README.md)).
  232. - On AgentDojo, per-argument taint misses 61 of 702 attacker write calls; session-level taint
  233. misses none of them and escalates three in four benign tasks.
  234. - The default stack reaches 86.4% and 98.4% recall on two independent datasets (SPML and
  235. yanismiraoui), but on long prompts (around 2,000 characters and up) the classifier mostly
  236. times out within its 250 ms budget and the request falls back to the heuristic.
  237. Treat every detection number as a speed bump that raises attacker cost, never as a defence.
  238. ## Not built yet
  239. - **It is only as good as your declarations.** A destructive tool declared `read` is treated
  240. as `read`. `agentfox doctor` grades this; `agentfox scan` finds undeclared tools.
  241. - **You declare the estate yourself.** No Okta, no DataHub; principals and grants live in AgentFox.
  242. - **Compliance mappings are DRAFT**, not reviewed by counsel, and labelled so in every export.
  243. - **No live IdP or SSO.** Multi-tenancy is enforced at the session within one deployment, and only text is inspected.
  244. Live per-capability status, computed by probe: [docs/status.md](https://github.com/architsharm/agentfox/blob/main/docs/status.md).
  245. ## Documentation
  246. | | |
  247. |---|---|
  248. | [Website docs](https://useagentfox.com/docs) | Install, guides for every integration, and the CLI, API and config reference |
  249. | [Getting started](https://github.com/architsharm/agentfox/blob/main/docs/getting-started.md) | The short path, then a linear first hour ending with your own agent governed |
  250. | [Product tour](https://github.com/architsharm/agentfox/blob/main/docs/product-tour.md) | The reference view: every integration surface, commands by task, the demo output, self-hosting |
  251. | [ARCHITECTURE.md](https://github.com/architsharm/agentfox/blob/main/ARCHITECTURE.md) | The domain model, a tool call traced through the code, and the code map |
  252. | [CONTRIBUTING.md](https://github.com/architsharm/agentfox/blob/main/CONTRIBUTING.md) | Setup in three commands, `just ci`, and the conventions |
  253. | [docs/](https://github.com/architsharm/agentfox/blob/main/docs/README.md) | Design, threat model, requirements and how the numbers were measured |
  254. | [Benchmarks](https://github.com/architsharm/agentfox/blob/main/benchmarks/README.md) | Every number above, with the script that reproduces it |
  255. | [SECURITY.md](https://github.com/architsharm/agentfox/blob/main/SECURITY.md) | Report a vulnerability privately; please not in a public issue |
  256. Questions and ideas go to [Discussions](https://github.com/architsharm/agentfox/discussions);
  257. bugs to [Issues](https://github.com/architsharm/agentfox/issues/new/choose). New contributors:
  258. start with a [good first issue](https://github.com/architsharm/agentfox/labels/good%20first%20issue).
  259. ## Licence
  260. The open core is [Apache-2.0](https://github.com/architsharm/agentfox/blob/main/LICENSE): the SDKs, the gateway and CLI, enforcement and
  261. containment, every detector and validator, custom rules, policy packs, the benchmarks and the
  262. dashboard. It runs on its own, with no licence key and no limit on agents.
  263. [AgentFox Enterprise](https://github.com/architsharm/agentfox/blob/main/ee/README.md) (`ee/`) adds what an organisation needs to govern many
  264. agents and prove it: compliance status against EU AI Act, ISO 42001, SOC 2 and NIST AI RMF,
  265. auditor evidence packages, fleet monitoring with alerts, and checks against your own access
  266. control. It is source-available under the [Business Source License 1.1](https://github.com/architsharm/agentfox/blob/main/ee/LICENSE): free in
  267. production for one workspace with up to four agents, and **each release becomes Apache-2.0
  268. three years after it ships**. It is included on AgentFox Cloud.

Ratings and comments

Sign in to rate this skill.

Sign in

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