No entries match these filters. Clear filters
nono adds login/logout commands, session terminal recording, Unix-socket webhook approvals, and AWS operation-level endpoint policy matching︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ GET THIS VERSIONHomebrew Docker git
Homebrew
copy
$ brew install nono
$ brew upgrade nono
Docker
copy
$ docker pull ghcr.io/nolabs-ai/nono:0.82.0
git
copy
$ git clone --branch v0.82.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.82.0
Homebrew lists this version · published under the project's GitHub account · checked 15 Nov
└──▷ TRY IT
Authenticate with the nono platform using device-flow OAuth before accessing remote sessions or audit delivery.
Restrict an AWS credential grant so the agent can only call specific S3 operations, not arbitrary API actions.
yaml
copy
operations:
- s3:GetObject
- s3:PutObject
Review what an agent did during a session by printing its terminal recording as text.
copy
$ nono transcript <session-id>
Add nono login and nono logout commands for OAuth 2.0 OAuth 2.0 An open authorization framework (IETF RFC 6749) that lets a service grant limited API access to a third party without sharing credentials, giving cyber tools a standard way to authenticate against external platforms. device-flow authentication and platform enrollment.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds session terminal recording (NEP-0010) so agent sessions are captured for later review, along with nono replay and nono transcript commands to play back or print a session's terminal recording. Not checked yet Adds new approval capabilities to nono proxy: a Unix-socket webhook transport for approval backends enabling local out-of-process approval daemons over AF_UNIX pathname sockets, approval elevation for AF_UNIX pathname socket connect and bind operations on Linux, a network approval flow for plain-HTTP forward requests, and approvals for allow_domain endpoints. Not checked yet Add operations field to EndpointRuleConfig so endpoint_policy on aws_auth routes can match specific AWS operation-name globs. Not checked yet Add phantom_format to custom credentials configuration to control token format for phantom-token injection. Not checked yet
+4 more
show less
Unify platform commands under a reorganized platform command with automatic enrollment. Not checked yet Improves aws_auth routing by selecting the signing profile via placeholder access key ID, deriving the signing region from the request host for wildcard upstream configurations, and accepting AWS GovCloud regions and S3 bucket-subdomain wildcards in aws_auth proxy routes. Not checked yet Record proxy audit events live to the audit log as they occur rather than only at session finalization. Not checked yet Add remote command group to launch, list, and connect to remote sessions. Not checked yet
Add nono login and nono logout commands for OAuth 2.0 OAuth 2.0 An open authorization framework (IETF RFC 6749) that lets a service grant limited API access to a third party without sharing credentials, giving cyber tools a standard way to authenticate against external platforms. device-flow authentication and platform enrollment.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds session terminal recording (NEP-0010) so agent sessions are captured for later review, along with nono replay and nono transcript commands to play back or print a session's terminal recording. Not checked yet Adds new approval capabilities to nono proxy: a Unix-socket webhook transport for approval backends enabling local out-of-process approval daemons over AF_UNIX pathname sockets, approval elevation for AF_UNIX pathname socket connect and bind operations on Linux, a network approval flow for plain-HTTP forward requests, and approvals for allow_domain endpoints. Not checked yet Add operations field to EndpointRuleConfig so endpoint_policy on aws_auth routes can match specific AWS operation-name globs. Not checked yet Add remote command group to launch, list, and connect to remote sessions. Not checked yet
4 more in Everything
└──▷ BREAKING ON UPGRADE
!
The `connect` subcommand is removed; remote session connectivity is now under the `remote` command group.
Our best guess
nono adds security.capability_elevation to route blocked socket paths to an approval backend instead of denying outright︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
nono's supervisor now accepts Unix socket URLs for local helper connections︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Route supervisor traffic to a local helper over a Unix socket instead of a network URL, keeping the connection off the network entirely.
json
copy
{
"url": "unix:///abs/path.sock"
}
Connect a local helper over a Unix socket by setting "url": "unix:///abs/path.sock" in the supervisor config; the launch is refused if the sandbox could replace that socket.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet
1 detail in Everything
nono adds Unix socket support for the tool-sandbox HTTP endpoint, letting local helpers answer authorization requests via url: "unix:///abs/path.sock"︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Route tool-sandbox authorization requests to a local helper process over a Unix socket instead of a TCP TCP A network protocol that delivers a reliable, ordered stream of bytes between two endpoints. It detects lost data and retransmits it. HTTP endpoint, keeping traffic off the network.
yaml
copy
url: "unix:///abs/path.sock"
nono adds network approval backends, opt-in namespace isolation, and Landlock Landlock A Linux kernel access-control mechanism that lets an unprivileged process restrict its own filesystem and network access, giving cyber tools a way to sandbox themselves without root privileges. V9 detection alongside new policy groups and proxy denial logging︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ GET THIS VERSIONHomebrew Docker git
Homebrew
copy
$ brew install nono
$ brew upgrade nono
Docker
copy
$ docker pull ghcr.io/nolabs-ai/nono:0.81.0
git
copy
$ git clone --branch v0.81.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.81.0
Homebrew lists this version · published under the project's GitHub account · checked 30 Oct
└──▷ TRY IT
Check whether a sandboxed agent or tool is permitted to connect to a Unix socket such as the Docker daemon socket.
copy
$ nono why --unix-socket /run/docker.sock
Query pathname Unix socket connect access with nono why --unix-socket <path> to diagnose AF_UNIX policy decisions.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Add the rtk_state policy group to grant runtime-state access in profiles. Not checked yet Enable opt-in namespace isolation on Linux (NEP-0004) for stronger per-tool containment. Not checked yet nono now detects Landlock ABI up to V9, extending future-proofing for Linux kernel upgrades while keeping enforcement at V6. Not checked yet Proxy deny log lines now include denial_category, giving operators a structured field to filter and alert on blocked network requests. Not checked yet
+2 more
show less
Profiles now require fully qualified package profile names, making profile references unambiguous across registries. Not checked yet The exec gate on Linux now reads only the ELF ELF The standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. regions it actually parses, reducing per-execution overhead and enabling lower-latency sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. for workloads that spawn many processes. Not checked yet
Query pathname Unix socket connect access with nono why --unix-socket <path> to diagnose AF_UNIX policy decisions.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Add the rtk_state policy group to grant runtime-state access in profiles. Not checked yet Enable opt-in namespace isolation on Linux (NEP-0004) for stronger per-tool containment. Not checked yet Proxy deny log lines now include denial_category, giving operators a structured field to filter and alert on blocked network requests. Not checked yet
3 more in Everything
└──▷ BREAKING ON UPGRADE
!
Profiles now require fully qualified package profile names; bare/unqualified profile name references that worked in v0.80.0 will break on upgrade.
Our best guess
nono v0.80.0 adds SHA-256 SHA-256 A cryptographic hash function that turns data into a fixed 256-bit fingerprint. It is used to check integrity; hashing does not encrypt the original data. executable pinning, per-command AWS SigV4 SigV4 AWS's request-signing protocol that authenticates HTTP calls by hashing the request body, headers, and credentials into a signature; cyber tools use it to talk to AWS APIs without embedding long-lived secrets. auth, and macOS keychain_access keychain_access A macOS system service and GUI app from Apple that stores and retrieves passwords, certificates, and keys from encrypted keychains, giving cyber tools a native credential store without managing their own crypto. grants for tool sandboxes.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.80.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.80.0
└──▷ USE IT
Pin a sandboxed tool to its exact binary so a supply-chain swap or path-hijack is caught before execution.
json
copy
{
"command_policies": {
"commands": {
"gh": {
"executable": "/usr/local/bin/gh",
"sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
}
}
}
}
Adds sha256 field to CommandPolicyConfig in the command-policy config to pin a command to its expected SHA-256 executable digest, blocking substituted or tampered binaries.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds aws_auth field (type AwsAuthConfig) to CommandCredentialConfig in the command-policy config, enabling per-command AWS SigV4 signing in tool-sandbox scoped-proxy routes — the child process sees only dummy keys while real credentials are resolved host-side. Not checked yet Adds command-level keychain_access grant for macOS, letting profiles permit a specific sandboxed command to access the macOS Keychain without widening the entire session sandbox. Not checked yet
Adds sha256 field to CommandPolicyConfig in the command-policy config to pin a command to its expected SHA-256 executable digest, blocking substituted or tampered binaries.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds command-level keychain_access grant for macOS, letting profiles permit a specific sandboxed command to access the macOS Keychain without widening the entire session sandbox. Not checked yet
1 more in Everything
nono command-sandbox proxy credentials now support aws_auth for SigV4 SigV4 AWS's request-signing protocol that authenticates HTTP calls by hashing the request body, headers, and credentials into a signature; cyber tools use it to talk to AWS APIs without embedding long-lived secrets. -signed AWS routing without exposing real credentials inside the sandbox.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Route sandboxed AWS Bedrock CLI calls through the host-side production AWS profile via SigV4 signing, keeping real credentials off the sandboxed process entirely.
json
copy
{
"bedrock": {
"proxy": {
"upstream": "https://bedrock-runtime.us-east-1.amazonaws.com",
"aws_auth": {
"profile": "production"
}
},
"endpoint_policy": [
{
"allow": {
"method": "POST",
"path": "/model/**"
}
}
]
},
"AWS_ACCESS_KEY_ID": "nono-placeholder",
"AWS_SECRET_ACCESS_KEY": "nono-placeholder",
"AWS_CONFIG_FILE": "/dev/null",
"AWS_SHARED_CREDENTIALS_FILE": "/dev/null"
}
Adds aws_auth as an alternative to credential_key on proxy credential type in command sandbox policies, letting the host supervisor resolve an AWS profile and sign outbound requests with SigV4 so real AWS credentials never enter the sandbox.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds aws_auth.profile config key to specify which host-side AWS profile (including SSO SSO Single sign-on, using one identity provider to sign in to multiple applications. It reduces separate passwords and centralizes account and access management. profiles) is used for signing permitted outbound requests from a command-scoped proxy credential. Not checked yet Supports setting AWS_CONFIG_FILE and AWS_SHARED_CREDENTIALS_FILE to /dev/null inside the sandbox to prevent the sandboxed CLI from probing ~/.aws, while aws_auth.profile is still resolved by the host supervisor. Not checked yet Supports non-secret AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY placeholder values inside the sandbox to satisfy client-side credential checks before the proxy removes their signature and re-signs with host-side credentials. Not checked yet
4 details in Everything
nono adds diagnostics.redaction.extra_env_vars and network_denial_audit rate-limit controls for audit hygiene︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Prevent a CI-injected deploy token and any secret-suffixed vars from appearing in audit logs, alongside the profile's existing deny rules.
toml
copy
[diagnostics]
[diagnostics.redaction]
extra_env_vars = ["DEPLOY_TOKEN", "ACME_*", "*_SECRET"]
Cap audit noise from a chatty process that hammers a blocked endpoint, keeping the log small while still enforcing every denial.
toml
copy
[network_denial_audit]
rate_per_sec = 5
burst = 20
Temporarily capture every network denial for a single debugging run without modifying the profile.
copy
$ nono run --network-denial-audit-rate 1000 --network-denial-audit-burst 10000 -- ./my-service
Adds diagnostics.redaction.extra_env_vars config key to redact additional environment variable values (by exact name or glob such as ACME_*, *_SECRET) from diagnostics, session records, and the audit log — for variables not already derived from the profile's deny or credential declarations.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds network_denial_audit profile section with rate_per_sec (max 1000) and burst (max 10000) integer fields to control how many per-run network syscall denials are individually recorded in the audit trail on Linux seccomp-mediated runs. Not checked yet Adds --network-denial-audit-rate and --network-denial-audit-burst CLI flags to override the network_denial_audit profile settings for a single run. Not checked yet Automatically redacts exact environment.deny_vars entries and all credential destinations (command_policies.credentials, network.custom_credentials, credential_routes env_var fields) from diagnostics and the audit log without requiring a separate redaction declaration. Not checked yet Denied connections past the audit budget are still enforced and emit a single summary audit event (e.g. '50 network syscall denials were enforced but not individually recorded (audit rate limit exceeded)') rather than being silently dropped from the log. Not checked yet
5 details in Everything
nono adds diagnostics.redaction.extra_env_vars to scrub additional environment variables from diagnostics and audit logs︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Scrub a deployment credential and a wildcard family of secrets from diagnostics and audit logs when they are passed through the host environment rather than declared in the profile.
yaml
copy
diagnostics:
redaction:
extra_env_vars:
- "DEPLOY_TOKEN"
- "ACME_*"
- "*_SECRET"
Derives automatic redaction from environment.deny_vars exact-name entries and from command_policies.credentials, network.custom_credentials, and credential_routes env_var destinations — no separate redaction declaration needed for these. Not checked yet Supports glob syntax (e.g. ACME_*, *_SECRET) matched case-insensitively against the full variable name, using the same matcher as environment.deny_vars. Not checked yet Merges extra_env_vars additively across profile inheritance, so child profiles widen the inherited redaction list rather than replacing it. Not checked yet Records names added via a profile in the audit log's redaction-policy diff, so each audit record documents how its own scrubbing differed from the default. Not checked yet Requires [redaction].unsafe_redaction_overrides in user config to remove a secure default from the redaction list — profile-level entries are add-only. Not checked yet
Supports glob syntax (e.g. ACME_*, *_SECRET) matched case-insensitively against the full variable name, using the same matcher as environment.deny_vars. Not checked yet Merges extra_env_vars additively across profile inheritance, so child profiles widen the inherited redaction list rather than replacing it. Not checked yet Records names added via a profile in the audit log's redaction-policy diff, so each audit record documents how its own scrubbing differed from the default. Not checked yet Requires [redaction].unsafe_redaction_overrides in user config to remove a secure default from the redaction list — profile-level entries are add-only. Not checked yet
1 more in Everything
nono v0.79.0 adds remote agent session launch, proxy denial diagnostics, Snap policy group, and diagnostics.redaction.extra_env_vars︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.79.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.79.0
└──▷ TRY IT
Attach interactively to a remote agent workspace — useful for inspecting or resuming a long-running sandboxed session from another machine.
copy
$ nono run --remote --agent claude --workspace my-project
Launch a remote agent session in the background without attaching, then walk away — the session runs detached under the sandbox policy.
copy
$ nono run --remote --agent claude --workspace my-project --detached
Adds --remote, --agent, --workspace, and --detached flags to nono run to launch and attach to remote agent sessions.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds diagnostics.redaction.extra_env_vars profile key to redact additional environment variables from diagnostic output. Not checked yet Renders proxy network denials in the CLI diagnostic footer so blocked outbound calls are visible at a glance. Not checked yet
Adds --remote, --agent, --workspace, and --detached flags to nono run to launch and attach to remote agent sessions.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds diagnostics.redaction.extra_env_vars profile key to redact additional environment variables from diagnostic output. Not checked yet
1 more in Everything
└──▷ BREAKING ON UPGRADE
! Legacy Claude hook cleanup code has been removed (feat(cli)!: remove legacy Claude hook cleanup); any setup relying on that automatic cleanup will no longer have it performed on upgrade.
nono adds Sandboxed Tool Execution with per-command filesystem, network, and credential grants brokered through a command sandbox policy︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Sandbox curl to HTTPS HTTPS HTTP carried over an encrypted TLS connection. It protects traffic in transit and lets a browser verify the server's certificate. -only traffic by defining a command sandbox policy that restricts network access to port 443 via a proxy credential, preventing any direct or unproxied connections.
~/.config/nono/profiles/my-command-policy-profile.json
copy
{
"commands": {
"curl": {
"from": {
"session": {
"sandbox": {
"network": {
"credentials": ["command-curl-https"]
}
}
}
}
}
}
}
Adds commands.<name>.from.session.sandbox config key to define a direct-session command sandbox policy, scoping a named command's filesystem, network, and credential grants independently of the session sandbox.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds commands.<name>.from.<caller>.sandbox config key to define caller-specific command sandbox policies, enabling chained tool execution where each hop receives its own narrowly scoped policy. Not checked yet Adds network.allow_all field within a command sandbox policy to grant unrestricted network access to a specific command sandbox. Not checked yet Adds command-scoped proxy policy: a command sandbox whose network policy includes a proxy credential receives a dedicated loopback proxy and fresh proxy credential, isolated from the session sandbox's broader domain allowlist. Not checked yet Adds NO_PROXY awareness to command sandbox proxy enforcement — setting NO_PROXY or opening a direct socket does not bypass network policy unless the command sandbox policy separately grants raw TCP TCP A network protocol that delivers a reliable, ordered stream of bytes between two endpoints. It detects lost data and retransmits it. access. Not checked yet
+11 more
show less
Adds endpoint_policy field so proxy credential reverse routes may reach configured upstreams without adding those upstreams to the command sandbox's domain allowlist. Not checked yet Adds per-command trust downgrade for pinned executables writable by the session sandbox capability set, requiring an absolute path. Not checked yet Adds profile-wide trust downgrade option to disable the writable-executable trust check across command mediation for low-assurance profiles. Not checked yet Supports intercept sandboxes that replace the selected command sandbox for a matched invocation, validated for well-formedness but not restricted to narrowing the base sandbox. Not checked yet Adds dynamic provider token expansion in command sandbox path grants — tokens are expanded at launch before the sandbox is built and are opt-in. Not checked yet Supports shebang script mediation: scripts detected by entrypoint are classified as shebang scripts and the command sandbox grants the script, its interpreter, and the interpreter's ELF ELF The standard binary format for executables, shared libraries, and object files on Linux and most Unix-like systems, giving cyber tools a predictable structure to parse, instrument, or analyze compiled code. loader closure. Not checked yet Adds Linux cgroup-based caller attribution so mediated commands spawned by double-forking daemons (e.g. tmux servers) are still attributed correctly rather than falling back to a replayable identity. Not checked yet Adds optional command sandbox resource limits field within a command sandbox policy. Not checked yet Adds seatbelt escape-hatch field (macOS only) to append raw Seatbelt rules after the deny gate for a specific command sandbox. Not checked yet Supports two credential types in command sandbox policies: named credentials injected into the selected sandbox and local-socket credentials backed by SSH_AUTH_SOCK. Not checked yet Provides example profiles command-jq-readonly, command-curl-https, command-git-ssh, and command-make-cc stored under ~/.config/nono/profiles/ illustrating common sandboxed tool configurations. Not checked yet
16 details in Everything
nono adds sandboxed tool execution and dangerous command blocking via command policies︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
Adds sandboxed tool execution to run selected commands in zero-trust command sandboxes with brokered chaining.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds dangerous command blocking to prevent destructive commands via command policies. Not checked yet
2 details in Everything
nono v0.78.0 adds backend-signed approval webhooks, macOS DNS opt-out, and a Nix #prebuilt flake output︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.78.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.78.0
└──▷ USE IT
Wire a profile's approval backend to your enrolled platform so every approval request is cryptographically signed and uses submit-and-poll instead of a plain webhook.
json
copy
{
"approval_backends": {
"my-backend": {
"backend_type": "webhook",
"auth": "platform"
}
}
}
Install nono instantly in a Nix environment without compiling from source — useful in CI or on machines without a Rust toolchain.
copy
$ nix run github:nolabs-ai/nono#prebuilt
Adds CapabilitySet::block_dns() (and C-API nono_capability_set_block_dns() / nono_capability_set_dns_enabled() ) on macOS to opt out of implicit mDNSResponder grants in Blocked and ProxyOnly network modes. Not checked yet Adds #prebuilt Nix flake Nix flake A Nix packaging construct that pins all dependencies in a lockfile and exposes a standardized interface, giving cyber tools fully reproducible builds across any machine running the Nix package manager. output to fetch the official release binary directly from GitHub Releases, skipping source compilation. Not checked yet Removes all remaining deprecated surfaces and legacy aliases as part of v1.0.0 preparation. Not checked yet
Adds #prebuilt Nix flake Nix flake A Nix packaging construct that pins all dependencies in a lockfile and exposes a standardized interface, giving cyber tools fully reproducible builds across any machine running the Nix package manager. output to fetch the official release binary directly from GitHub Releases, skipping source compilation. Not checked yet
2 more in Everything
└──▷ BREAKING ON UPGRADE
! All remaining deprecated CLI surfaces and legacy profile aliases removed — any profile or script relying on them will break on upgrade.
nono tool-sandbox adds webhook and chain approval backends with configurable auth and multi-backend chaining︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Require platform-signed approval before any sandboxed tool runs, using the enrolled platform's approval route.
yaml
copy
type: webhook
auth: "platform"
Require both terminal confirmation and a webhook to approve a tool call, so two channels must agree before execution proceeds.
yaml
copy
type: chain
mode: all
backends:
- type: terminal
- type: webhook
url: https://approvals.example.com/hook
Adds webhook approval backend with url and auth fields; set auth: "platform" to sign requests with the enrollment key and use the submit-and-poll exchange against the enrolled platform's approval route.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds chain approval backend with mode (default all) and backends fields to combine multiple approval backends. Not checked yet Adds terminal approval backend to prompt the operator directly in the terminal. Not checked yet
3 details in Everything
nono gains nono session cleanup command to remove sessions from the CLI.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Clean up terminated sessions from the nono runtime — note: avoid running against paused/stopped sessions until conservative handling is tightened.
copy
$ nono session cleanup
nono adds live sandbox session management with ps, attach, detach, stop, inspect, and cleanup commands︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
nono v0.77.0 removes all legacy profile aliases and shims, and switches network-notification sessions to CLONE_FILESCLONE_FILES A Linux kernel flag passed to `clone()` that makes a new process share the parent's file-descriptor table rather than copying it, saving overhead when a tool spawns many lightweight worker threads. bootstrap.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.77.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.77.0
Removes all legacy profile-key aliases, CLI flag aliases (including --allow-net, --net-allow, and env vars NONO_NET_BLOCK, NONO_NET_ALLOW, NONO_PROXY_CREDENTIAL, etc.), and the nono policy subcommand — these now fail to parse instead of warning.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Switches network-notification session bootstrap to use CLONE_FILES, improving session startup for that session type. Not checked yet
Removes all legacy profile-key aliases, CLI flag aliases (including --allow-net, --net-allow, and env vars NONO_NET_BLOCK, NONO_NET_ALLOW, NONO_PROXY_CREDENTIAL, etc.), and the nono policy subcommand — these now fail to parse instead of warning.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet
1 more in Everything
└──▷ BREAKING ON UPGRADE
! The nono policy subcommand (and all its sub-forms such as nono policy groups, nono policy profiles, nono policy show) is removed — use nono profile equivalents instead.! Legacy profile keys and CLI flag aliases (--allow-net, --net-allow, and others) and environment variable aliases (NONO_NET_BLOCK, NONO_NET_ALLOW, NONO_ALLOW_PROXY, NONO_PROXY_ALLOW, NONO_PROXY_CREDENTIAL, NONO_EXTERNAL_PROXY, NONO_EXTERNAL_PROXY_BYPASS) are removed and now fail to parse — replace with their current equivalents.! The nono prune subcommand is removed from the CLI.! Profile JSON keys security.allowed_commands and policy.add_deny_commands are no longer accepted — use commands.allow and commands.deny respectively.
nono audit gains cleanup subcommand with --keep, --older-than, --max-total-size, and --dry-run filters to prune old audit sessions from disk.
└──▷ TRY IT
Preview which audit sessions would be removed before committing to a cleanup — useful before running in CI or on a shared system.
copy
$ nono audit cleanup --keep 10 --max-total-size 500 --dry-run
Enforce a rolling retention policy that keeps only sessions from the last 30 days and caps total disk usage at 500 MB, removing oldest sessions first.
copy
$ nono audit cleanup --older-than 30 --max-total-size 500
Supports combining --keep, --older-than, and --max-total-size filters so each narrows further which sessions are removed. Not checked yet
1 more in Everything
nono v0.76.0 adds --max-total-size to audit cleanup, Nix flake Nix flake A Nix packaging construct that pins all dependencies in a lockfile and exposes a standardized interface, giving cyber tools fully reproducible builds across any machine running the Nix package manager. support, and unix_socket_bindunix_socket_bind A system call that assigns a filesystem path or abstract name to a Unix domain socket, letting processes on the same host find and connect to it without using a network port. for tool sandboxes
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.76.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.76.0
└──▷ TRY IT
Cap audit storage in CI environments where disk is limited — purge oldest sessions to stay under 500 MB without touching recent runs.
copy
$ nono audit cleanup --max-total-size 500
Grant a sandboxed git command access to its fsmonitor socket without giving the agent-level sandbox the same socket bind rights.
json
copy
{
"command_policies": {
"commands": {
"git": {
"from": {
"session": {
"sandbox": {
"fs_read": ["."],
"unix_socket_bind": ["/tmp/git-fsmonitor.sock"]
}
}
}
}
}
}
}
Adds --max-total-size <MB> flag to nono audit cleanup to evict oldest sessions until total audit storage falls below a specified megabyte threshold. Not checked yet Adds unix_socket_bind field to CommandSandboxConfig in tool-sandbox profiles, allowing per-command Unix domain socket grants (e.g. Git fsmonitor socket) without widening the agent-level sandbox. Not checked yet Adds Nix flake support, enabling nix run github:nolabs-ai/nono and nix profile add github:nolabs-ai/nono installs without Homebrew or the install script. Not checked yet
3 details in Everything
nono Tool Sandbox gains unix_socket_bindunix_socket_bind A system call that assigns a filesystem path or abstract name to a Unix domain socket, letting processes on the same host find and connect to it without using a network port. grants, @git:fsmonitor-socket token, and macOS per-session isolation for mediated commands
└──▷ USE IT
Allow a sandboxed build tool to bind and connect to a local sccache socket stored under $XDG_RUNTIME_DIR.
yaml
copy
unix_socket_bind:
- "$XDG_RUNTIME_DIR/sccache.sock"
Let a sandboxed git-aware tool reach the fsmonitor daemon socket for the current worktree without granting broad filesystem access.
yaml
copy
unix_socket_bind:
- "@git:fsmonitor-socket"
Adds unix_socket_bind grant type to tool sandbox policy, accepting a path array to allow connect(2) and bind(2) on named AF_UNIX socket files, with implied ReadWrite filesystem grants on the socket file or its parent directory. Not checked yet Adds @git:fsmonitor-socket dynamic path token that resolves to fsmonitor--daemon.ipc under the current worktree's private git-dir without spawning a process, enabling core.fsmonitor=true to reach its daemon socket inside a sandbox. Not checked yet On macOS, every mediated command now runs in its own POSIX POSIX A family of standards for operating-system interfaces, including process, file and shell behavior. Software that uses these interfaces is easier to move between compatible systems. session (setsid before exec), making session membership an unforgeable proof of descent for orphaned child processes. Not checked yet Supports environment-variable expansion in path values (e.g. $XDG_RUNTIME_DIR/sccache.sock), with a named-variable error at launch if the variable is unset. Not checked yet
Adds unix_socket_bind grant type to tool sandbox policy, accepting a path array to allow connect(2) and bind(2) on named AF_UNIX socket files, with implied ReadWrite filesystem grants on the socket file or its parent directory. Not checked yet Adds @git:fsmonitor-socket dynamic path token that resolves to fsmonitor--daemon.ipc under the current worktree's private git-dir without spawning a process, enabling core.fsmonitor=true to reach its daemon socket inside a sandbox. Not checked yet On macOS, every mediated command now runs in its own POSIX POSIX A family of standards for operating-system interfaces, including process, file and shell behavior. Software that uses these interfaces is easier to move between compatible systems. session (setsid before exec), making session membership an unforgeable proof of descent for orphaned child processes. Not checked yet
1 more in Everything
└──▷ BREAKING ON UPGRADE
! On macOS, mediated commands no longer have a controlling terminal: open("/dev/tty") fails with ENXIO, and TIOCSCTTY is refused — tools that prompt for passphrases or use a terminal credential helper directly will fail instead of prompting; supply credentials via environment, an askpass helper, or an agent socket.
nono v0.75.0 adds --extends to nono proxy, glob allow/deny patterns, --strict-broker-path, and resolved command_policies in profile show
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.75.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.75.0
└──▷ TRY IT
Compose an extra-domains profile on top of an existing proxy profile at runtime — useful when a specific session needs additional allow-listed hosts without permanently editing the base profile.
copy
$ nono proxy -p default --extends extra-domains
Harden a sandbox so it refuses to start if any filesystem grant overlaps a PATH directory — catch planted-binary risk in CI before the agent runs.
copy
$ nono run --profile nolabs-ai/opencode --strict-broker-path -- opencode
Shape a phantom credential token so a prefix-sniffing client (e.g. an Anthropic SDK checking for sk-ant-) still recognises it as valid while nono brokers the real secret.
json
copy
{
"command_policies": {
"credentials": {
"claude-key": {
"type": "ambient",
"env_var": "ANTHROPIC_API_KEY",
"format": "sk-ant-oat01-{}"
}
}
}
}
Adds --extends <PROFILE> to nono proxy, enabling the same repeatable profile-composition semantics already available on nono run — requires --profile to be set. Not checked yet Adds --strict-broker-path flag to sandbox args: refuses to start instead of warning when a filesystem grant overlaps a directory on PATH, blocking planted-binary attacks on host processes outside the sandbox. Not checked yet Adds glob pattern support for env var and hostname allow/deny lists in profile and proxy network configuration. Not checked yet Adds a format field to CommandCredentialConfig for ambient credentials: a literal template (e.g. sk-ant-oat01-{}) that shapes the visible phantom token so prefix-sniffing clients recognise it. Not checked yet Sanitizes PATH for host-side credential and URL brokers, preventing bare-name binary resolution from grants that overlap PATH directories. Not checked yet
+1 more
show less
Ships an initial set of tool sandbox examples demonstrating command_policies configurations. Not checked yet
6 details in Everything
nono adds deny_domain config key and --deny-domain CLI flag with three wildcard forms for precise host blocking.
└──▷ USE IT
Block ad-serving subdomains as an exception inside a broad allow rule, using the deny_domain config key.
yaml
copy
deny_domain:
- "*.ads.example.com"
- "jenkins.*.ci.example.com"
Block a specific subdomain pattern at the CLI without modifying the profile file.
copy
$ nono --deny-domain '*.ads.example.com'
Adds deny_domain config key to block specific hosts through the proxy before the allowlist is checked, letting it carve exceptions out of broad network profile entries. Not checked yet Adds --deny-domain CLI flag as the command-line equivalent of the deny_domain config key. Not checked yet Supports three wildcard forms in deny_domain entries: a bare * matches any host; a leading * (e.g. *.example.com) matches one or more subdomain labels but not the apex; and a * occupying a whole label elsewhere (e.g. jenkins.*.ci.example.com) matches exactly one label at that position. Not checked yet deny_domain is additive across profile inheritance and is evaluated before the allowlist, so it can override broad network_profile entries. Not checked yet Invalid wildcard patterns — where * occupies only part of a label (e.g. foo*bar.com) or a leading * is combined with another * elsewhere — are rejected at profile load time rather than silently matching nothing. Not checked yet
5 details in Everything
nono CLI gains wildcard pattern matching and case-insensitive variable filtering for environment profiles
└──▷ USE IT
Allow only AWS session tokens and any var ending in _TOKEN into a sandboxed run, blocking everything else.
yaml
copy
allow_vars:
- "AWS_*_SESSION"
- "*_TOKEN"
Enable case-insensitive variable matching so patterns work regardless of casing conventions across different CI environments.
yaml
copy
case_insensitive_vars: true
allow_vars:
- "gh_token"
- "*_secret"
Adds * wildcard support anywhere in environment variable patterns (leading, trailing, or middle) within profile config, matching any run of characters — e.g. *_TOKEN, AWS_*_SESSION, *SECRET*. Not checked yet Adds case_insensitive_vars: true config key to match variable names and patterns case-insensitively (ASCII only), so a pattern like gh_token also matches GH_TOKEN, Gh_Token, etc. Not checked yet case_insensitive_vars is sticky across extends: once a base profile sets it to true, child profiles cannot silently revert it. Not checked yet Patterns without * require an exact full-name match, reducing risk of accidental over-permission. Not checked yet Malformed patterns (empty string or containing a NUL byte) are now rejected at profile load time rather than silently ignored at runtime. Not checked yet
5 details in Everything
nono ambient credentials gain a format field to shape phantom token prefixes for picky clients
└──▷ USE IT
Ensure a phantom issued for an Anthropic OAuth ambient credential carries the expected sk-ant-oat01- prefix so the consuming client accepts it without extra configuration.
yaml
copy
format: "sk-ant-oat01-{}"
Adds a format field to ambient credential declarations, accepting a literal template with exactly one {} placeholder (e.g. "sk-ant-oat01-{}"), so phantoms are issued with a recognizable prefix instead of a bare token — the template is stripped on egress so the real credential is never exposed upstream. Not checked yet format is rejected on non-ambient credentials, when the value contains control characters, or when the minting rule also sets shape: "jwt". Not checked yet
2 details in Everything
nono v0.74.0 adds remote session connect/ps, subtool audit surfacing, export_env pass-through, and configurable approval backends
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.74.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.74.0
└──▷ TRY IT
List all live and exited sessions running on the enrolled tenant's nono-console — useful for incident triage across a team.
copy
$ nono ps --remote --all --json
Attach your terminal directly to a known remote session by its global session ID.
copy
$ nono connect local:host:abc123
Adds nono connect subcommand to attach this terminal to a session hosted by nono-console; accepts a session ID (e.g. local:host:abc123) or URL directly. Not checked yet Extends nono ps with --remote flag to list sessions hosted by the enrolled tenant's nono-console, combinable with --all and --json. Not checked yet Adds export_env field to tool-sandbox CommandPolicyConfig and top-level session_export_env list in CommandPoliciesConfig, letting callers explicitly pass named env vars (exact names, trailing-* prefixes, or bare *) through to child processes, bypassing the dangerous-var blocklist. Not checked yet Adds configurable approval backend for supervised-mode prompts via approval_backends in the profile, letting operators route capability-approval decisions to different backends. Not checked yet
4 details in Everything
nono v0.73.0 adds glob pattern support in filesystem path fields for more flexible sandbox policies.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.73.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.73.0
Supports glob patterns in filesystem path fields (e.g. fs_read, fs_write) within profiles, enabling wildcard-based filesystem access rules in sandbox policies. Not checked yet
1 detail in Everything
nono v0.72.0 adds static seccomp network baseline on Linux, explicit deny-path reporting in why, and drops openclaw/swival built-in profiles.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.72.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.72.0
The why subcommand now reports explicit deny paths from the sandbox policy, making it easier to diagnose why a network or filesystem access was blocked. Not checked yet Removes openclaw and swival as built-in profiles; users relying on them must pull the equivalent packages from the registry. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The openclaw and swival built-in profiles have been removed; any setup using them will break on upgrade until the equivalent profiles are pulled from the registry.! The external --sandbox-policy mode on Linux no longer disables all nono sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. : Landlock still handles filesystem/process policy, and only TCP TCP A network protocol that delivers a reliable, ordered stream of bytes between two endpoints. It detects lost data and retransmits it. enforcement is delegated externally. Configurations that relied on external bypassing Landlock will behave differently.
nono v0.71.0 adds a new platform subcommand for enrollment and audit delivery to a control plane.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.71.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.71.0
└──▷ BREAKING ON UPGRADE
! The nono learn command has been removed; it was deprecated since v0.50.1.
nono v0.70.0 adds SPIFFE SPIFFE An open standard, maintained by the CNCF, for assigning cryptographic identities to workloads in dynamic infrastructure so services can authenticate each other without passwords or static credentials. /SPIRE workload identity workload identity An identity assigned to software, such as a service or container, rather than a person. It lets the workload authenticate and receive permissions without sharing a user's credentials. , per-route rate limiting, Vault OIDC OIDC OpenID Connect, a sign-in protocol built on OAuth 2.0. An application uses identity information from a trusted provider instead of maintaining a separate password for each user. mediation, JWT JWT An open standard (RFC 7519) for encoding claims as a signed, optionally encrypted JSON object passed between parties. Cyber tools use it to verify identity and permissions without querying a central session store. -shaped capture nonces, and profile-declared no_proxy bypass.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.70.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.70.0
Adds SPIFFE/SPIRE workload identity authentication for upstream proxy routes, enabling zero-trust service-to-service auth without static credentials. Not checked yet Adds per-route request rate limiting via RouteRateLimiter, letting profiles cap how many requests a sandboxed tool can make to a given upstream. Not checked yet Adds support for mediating vault login -method=oidc, including a custom inject header and per-command open_port to handle the OIDC browser callback. Not checked yet Adds a JWT-shaped nonce option (CapturedNonceShape::Jwt) for capture intercepts, producing a <header>.<payload>.nono_<64hex> token for consumers that validate token structure before use. Not checked yet Adds profile-declared no_proxy bypass support, allowing profiles to specify hosts that skip the nono proxy. Not checked yet
+1 more
show less
Offers to save denied open-URL origins on session exit, streamlining iterative policy development. Not checked yet
6 details in Everything
nono v0.69.0 adds SPIFFE SPIFFE An open standard, maintained by the CNCF, for assigning cryptographic identities to workloads in dynamic infrastructure so services can authenticate each other without passwords or static credentials. /SPIRE workload identity workload identity An identity assigned to software, such as a service or container, rather than a person. It lets the workload authenticate and receive permissions without sharing a user's credentials. auth for upstream proxy routes and profile-declared no_proxy bypass support.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.69.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.69.0
└──▷ USE IT
Bypass the nono proxy for internal hosts (e.g. a local Redis or internal registry) that should be reached directly.
json
copy
{
"no_proxy": ["redis", "registry.internal"]
}
Adds SPIFFE/SPIRE workload identity authentication for upstream proxy routes, supporting both JWT-SVID JWT-SVID A SPIFFE Verifiable Identity Document encoded as a JSON Web Token, used to prove workload identity across trust boundaries where X.509 certificates are impractical, such as HTTP headers. bearer injection and OAuth2 OAuth2 An open authorization framework (RFC 6749) that lets a service grant limited access to a user's resources on another service without exposing credentials, giving cyber tools a standard way to authenticate against third-party APIs. client assertion (RFC 7523 RFC 7523 An IETF standard that defines how a JSON Web Token (JWT) can be used as a credential to request an OAuth 2.0 access token, letting a cyber tool authenticate to an API without exchanging a username and password at runtime. ) flows; all flows are fail-closed if the SPIRE socket is unreachable. Not checked yet Adds profile-declared no_proxy bypass support, letting profiles specify hosts that skip the nono proxy. Not checked yet
2 details in Everything
nono v0.68.0 adds process-count caps, port ranges, per-OS profile overrides, domain blocking, plain HTTP proxy support, and bun/mise policy presets.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.68.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.68.0
└──▷ USE IT
Block a known data-exfiltration domain at the proxy layer for all traffic through a sandboxed agent.
json
copy
{
"deny_domain": ["exfil.example.com"]
}
Apply different filesystem grants on macOS vs Linux within a single shared profile using platform_overrides.
json
copy
{
"platform_overrides": {
"macos": {
"fs_read": ["/opt/homebrew"]
},
"linux": {
"fs_read": ["/usr/local"]
}
}
}
Adds --max-processes flag to cap the number of processes a sandbox may spawn (enforced via cgroup v2 pids.max). Not checked yet Adds port range support to sandbox profiles, enabling network rules that span a range of ports rather than individual ports. Not checked yet Adds platform_overrides field to profiles for per-OS patch sets, letting a single profile express different rules on macOS vs Linux. Not checked yet Adds deny_domain proxy configuration to explicitly block specific domains through the proxy. Not checked yet Adds exec_paths per-command tool-sandbox setting to support multi-call binaries (e.g. busybox-style) that need access to multiple executable paths. Not checked yet
+3 more
show less
Supports plain HTTP forward-proxying via the HTTP_PROXY environment variable. Not checked yet Adds built-in bun runtime policy preset for sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. Bun-based agents. Not checked yet Adds built-in mise policy preset for sandboxing mise-based tool workflows. Not checked yet
8 details in Everything
nono v0.67.0 adds a standalone proxy command, AWS SigV4 SigV4 AWS's request-signing protocol that authenticates HTTP calls by hashing the request body, headers, and credentials into a signature; cyber tools use it to talk to AWS APIs without embedding long-lived secrets. MitM auth, declarative OAuth capture, resource limiting, exec intercept, and richer sandbox token expansion.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.67.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.67.0
└──▷ TRY IT
Run the credential/filtering proxy on a fixed port with a specific domain allowlist — useful when an agent or CI job needs a pre-started proxy to route through.
copy
$ nono proxy --port 8080 --allow-domain api.github.com
Extend a community registry profile locally so you can add custom rules without forking the upstream profile.
copy
$ nono profile init opencode --extends always-further/opencode
Start a loopback proxy with no token auth for local development or testing pipelines that don't require authentication.
copy
$ nono proxy --port 8080 --no-auth
Adds nono proxy standalone command to run the network-filtering and credential-injection proxy as an independent server, with options for fixed port, no-auth mode, and domain allowlisting. Not checked yet Implements AWS SigV4 authentication for the MitM proxy, enabling signed AWS API request interception and credential injection. Not checked yet Adds declarative sandboxed OAuth capture, allowing profiles to define OAuth flows without manual credential handling. Not checked yet Introduces resource limiting support in sandbox profiles. Not checked yet Adds exec intercept action for tool-sandbox command policies, enabling a helper binary to replace a matched command's real binary inside the existing sandbox. Not checked yet
+5 more
show less
Supports per-intercept sandbox overrides and per-command unsafe_macos_seatbelt_rules escape hatch in tool-sandbox policies. Not checked yet Supports CLI profile extends inheritance, letting a local profile compose on top of a registry base profile. Not checked yet Expands $VAR tokens from the process environment in profile filesystem paths and capture commands. Not checked yet Expands @git:* dynamic tokens in top-level filesystem paths, including new git worktree tokens. Not checked yet Enables NVIDIA GPU GPU A graphics processing unit, a processor that performs many calculations in parallel. AI workloads use GPUs to speed up model training and inference. 570+ thread naming in sandbox mediation. Not checked yet
10 details in Everything
nono v0.66.0 adds HTTP/2 HTTP/2 The second major version of the HTTP protocol, standardized by the IETF, adding multiplexed streams, header compression, and binary framing over a single TCP connection to cut latency and reduce overhead. proxy support, a @git:common-dir dynamic token, and a simplified self-invocation policy for tool sandboxes.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.66.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.66.0
└──▷ TRY IT
Enable HTTP/2 multiplexing when running an agent that makes many concurrent requests through the credential proxy (e.g., Maven/Gradle artifact downloads) to improve throughput.
copy
$ nono run --profile always-further/opencode --allow-http2 -- opencode
Adds --allow-http2 flag to enable HTTP/2 multiplexing (via ALPN) for reverse proxy and credential injection upstream connections. Not checked yet Adds @git:common-dir dynamic token for tool-sandbox profiles, allowing policies to reference the Git common directory at runtime. Not checked yet Simplifies self-invocation policy for sandboxed tools, reducing boilerplate needed when a tool is permitted to call itself. Not checked yet
3 details in Everything
nono v0.65.0 introduces a tool sandbox for isolating tool execution environments.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.65.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.65.0
Adds a tool sandbox capability to isolate tool execution at runtime. Not checked yet
1 detail in Everything
nono v0.65.0 introduces tool sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. , giving delegated tools their own isolated child sandboxes with separate filesystem, network, and credential policies.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.65.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.65.0
└──▷ TRY IT
Restrict gh so the agent can only list and view issues — not comment — and inject a credential-proxied GitHub token scoped to those API paths only.
copy
$ nono run --profile opencode -- opencode
Diagnose why the tool sandbox blocked a gh issue comment invocation — useful when tuning command_policies argv allow-lists.
copy
$ nono why --profile gh --command gh -- issue comment 1052
Define a tool sandbox policy in your profile that scopes gh to read-only issue access with a proxied credential and an L7 endpoint allow-list.
json
copy
{
"command_policies": {
"credentials": {
"github-api": {
"type": "proxy",
"upstream": "https://api.github.com",
"credential_key": "keyring://gh:github.com/example?decode=go-keyring",
"env_var": "GH_TOKEN",
"inject_header": "Authorization",
"credential_format": "Bearer {}"
}
},
"commands": {
"gh": {
"from": {
"session": {
"sandbox": {
"fs_read": ["."],
"credentials": [
{
"name": "github-api",
"endpoint_policy": {
"default": "deny",
"allow": [
{ "method": "GET", "path": "/repos/nolabs-ai/nono/issues/**" }
]
}
}
]
},
"invocation_policy": {
"default": "deny",
"allow": [
{ "argv": { "prefix": ["issue", "list"] } },
{ "argv": { "prefix": ["issue", "view"] } }
]
}
}
}
}
}
}
}
Adds tool sandbox (ETI): delegated tools such as git, gh, and curl now run in isolated child sandboxes with their own fs_read/fs_write, network rules, credential grants, and argv invocation policies — independent of the agent's session sandbox. Not checked yet Enables per-tool credential proxy injection via command_policies.credentials, letting profiles expose a proxied token to a specific tool (e.g. gh) while enforcing L7 endpoint and HTTP-method allow-lists on that token. Not checked yet Extends nono why to diagnose tool-sandbox argv policy denials via --command <cmd> -- <args…>, in addition to its existing filesystem and network queries. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! Custom credentials now require explicit activation; previously working custom credential configurations will no longer function without being explicitly activated.
nono v0.64.0 adds AWS auth config, macOS blocked-grant visibility, CI environment detection, and structured diagnostics for library/FFI clients.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.64.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.64.0
└──▷ USE IT
Authenticate outbound AWS API calls through the nono proxy without managing credentials manually.
yaml
copy
# In your nono profile config
aws_auth:
enabled: true
New aws_auth config block enables AWS authentication support in the proxy. Not checked yet Capability summary now shows blocked macOS grants, giving practitioners a clear view of denied sandbox permissions. Not checked yet Update-check now detects CI environments automatically, suppressing irrelevant update prompts in pipelines. Not checked yet Structured diagnostics exposed via library and FFI interfaces, enabling programmatic access to diagnostic output. Not checked yet
4 details in Everything
nono v0.64.0 adds AWS auth config, structured diagnostics JSON output, CI environment detection, and macOS blocked-grants visibility.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.64.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.64.0
└──▷ TRY IT
Capture machine-readable session diagnostics after a run to feed into a SIEM SIEM Security information and event management, collecting logs from many systems and correlating events to find suspicious activity. Analysts use it to investigate alerts and incidents. or audit pipeline.
copy
$ nono run --profile always-further/opencode --diagnostics-json -- opencode 2>session-diagnostics.json
Adds aws_auth config support, enabling native AWS credential handling in agent sandbox profiles. Not checked yet New --diagnostics-json flag on nono run emits structured session diagnostics as JSON on stderr, including proxy diagnostics when present. Not checked yet Update-check now detects CI environments, suppressing spurious upgrade prompts in automated pipelines. Not checked yet Capability summary now surfaces blocked macOS grants, giving practitioners a clearer view of what the sandbox is denying on macOS. Not checked yet Exposes structured diagnostics for library and FFI clients, enabling programmatic access to session diagnostic data from Rust, Python, TypeScript, and Go bindings. Not checked yet
5 details in Everything
nono v0.63.0 adds static env injection, keyring timeout control, $PACK_DIR in session hooks, and XDG XDG A set of specifications maintained by freedesktop.org that standardise where Linux applications store config, data, and cache files, letting tools respect user-defined paths instead of hardcoding locations. state dir migration.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.63.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.63.0
└──▷ TRY IT
Prevent keychain prompts from hanging indefinitely in automated pipelines by capping how long nono waits for keyring access.
copy
$ NONO_KEYRING_TIMEOUT_SECS=10 nono run -- <command>
Adds set_vars for static environment variable injection into sandboxed sessions. Not checked yet Adds NONO_KEYRING_TIMEOUT_SECS environment variable to control keychain access timeout. Not checked yet Adds $PACK_DIR variable support in session hooks, enabling store pack workflows. Not checked yet Moves runtime state to XDG state directories for cleaner system integration. Not checked yet
4 details in Everything
nono v0.63.0 adds static env injection, keyring timeout control, $PACK_DIR in session hooks, and XDG XDG A set of specifications maintained by freedesktop.org that standardise where Linux applications store config, data, and cache files, letting tools respect user-defined paths instead of hardcoding locations. state dir support.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.63.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.63.0
└──▷ TRY IT
Inject a fixed environment variable into every sandboxed session — useful for pinning model names or feature flags without leaking them through the host environment.
copy
$ nono run --profile always-further/opencode -- opencode
Prevent indefinite hangs when the system keyring is locked or unavailable — useful in headless CI environments where keychain prompts never appear.
copy
$ NONO_KEYRING_TIMEOUT_SECS=5 nono run --profile always-further/opencode -- opencode
Adds set_vars profile field for static environment variable injection into sandboxed sessions — set fixed env values without exposing them through the agent's environment. Not checked yet Adds NONO_KEYRING_TIMEOUT_SECS environment variable to control how long nono waits for keychain/keyring access before timing out. Not checked yet Adds $PACK_DIR expansion support in session_hooks, enabling hooks to reference the store pack directory for pack-aware scripts. Not checked yet Moves CLI runtime state to XDG state directories, aligning with the XDG Base Directory specification for cleaner system integration. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! Runtime state is moved to XDG state directories (feat(cli): move runtime state to XDG state dirs), which may break setups that reference the previous runtime state paths.
nono v0.61.1 lets profiles extend from registry references, enabling shared policy inheritance across repos.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.61.1 https://github.com/nolabs-ai/nono.git
$ git checkout v0.61.1
Supports registry references in profile extends fields, enabling profiles to inherit from centrally-managed registry entries. Not checked yet
1 detail in Everything
nono v0.61.0 adds a profile option to suppress system service diagnostics output.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.61.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.61.0
└──▷ BREAKING ON UPGRADE
! Credentials are no longer enabled by default in network-policy profiles; existing profiles that relied on credentials being enabled by default will need to explicitly enable them.
nono v0.60.0 adds interactive denied-path selection, fine-grained allow_domain controls, configurable timeouts, and macOS CA trust-store integration.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.60.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.60.0
└──▷ TRY IT
Trust your corporate proxy CA via the macOS system keychain so nono doesn't reject intercepted TLS traffic.
copy
$ nono run --trust-proxy-ca <target>
New interactive denied path selector lets users pick and allow blocked paths without manually editing config. Not checked yet Supports fine-grained method+path restrictions inside allow_domain rules for tighter egress control. Not checked yet New --trust-proxy-ca flag integrates with the macOS system trust store for proxy CA validation. Not checked yet User-facing timeouts are now configurable via centralized timeout constants. Not checked yet Supports JSONC (JSON with comments) in wiring directives. Not checked yet
+3 more
show less
Annotates suppressed denials in output and styles save-prompt paths for clearer audit visibility. Not checked yet Removes libdbus dependency on Linux, simplifying deployment on minimal systems. Not checked yet RPM release artifacts now available for Red Hat-based distributions. Not checked yet
8 details in Everything
nono v0.59.0 adds suppressed-denial annotations, configurable timeouts, and fine-grained method+path allow_domain restrictions.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.59.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.59.0
Annotates suppressed denials in output and styles save-prompt paths for clearer audit visibility. Not checked yet Makes user-facing timeouts configurable via centralized timeout constants instead of hard-coded values. Not checked yet Supports fine-grained HTTP method+path restrictions inside allow_domain rules, enabling per-endpoint allowlisting. Not checked yet
3 details in Everything
nono v0.58.0 adds JSONC profile support, per-profile target binary, Bitwarden credential source, session lifecycle hooks, and a java-dev profile.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.58.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.58.0
└──▷ TRY IT
Use JSONC so you can annotate policy decisions directly in a profile file with inline comments.
copy
$ # myapp.jsonc
{
// Allow outbound HTTPS to internal API only
"allow": ["net:api.internal:443"]
}
Supports JSONC (JSON with comments) syntax in profile files for easier annotation of policy configs. Not checked yet Allows profiles to specify a target binary directly, scoping a profile to a particular executable. Not checked yet Adds Bitwarden credential source via the bw:// URI scheme for secret resolution. Not checked yet Introduces session lifecycle hooks to run commands or scripts at session start and end. Not checked yet Adds a java_runtime policy group and a java-dev built-in profile for sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. Java workloads. Not checked yet
5 details in Everything
nono v0.57.0 expands shadowing checks to cover pack profiles.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.57.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.57.0
Extends shadowing checks to include pack profiles, broadening detection coverage. Not checked yet
1 detail in Everything
nono v0.56.0 adds a configurable process startup timeout option to the CLI.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.56.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.56.0
nono v0.55.0 adds AF_UNIX socket sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. , Landlock v6 support, and profile signer verification.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.55.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.55.0
Adds Landlock v6 signal support and abstract Unix socket scoping on Linux. Not checked yet Adds recursive Unix socket directory grants via the CLI. Not checked yet Adds an explicit allowlist for pathname AF_UNIX sockets in the sandbox. Not checked yet Implements AF_UNIX pathname mediation on Linux for fine-grained socket access control. Not checked yet Verifies pack signer identities when pulling profiles and supports org/repo pull format. Not checked yet
+1 more
show less
On macOS, treats open_port 0 as a wildcard grant for all localhost outbound connections. Not checked yet
6 details in Everything
advisory CVE-2026-47128
May 17, 2026
·
issue 128
CVE-2026-47128: nono: Sandbox escape on Linux via D-Bus: systemd-run --user (CVSS CVSS Common Vulnerability Scoring System, a method for describing a vulnerability's characteristics and severity. Its score is not the probability that attackers will exploit it. 6.1, affects < 0.55.0)︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet
nono v0.54.0 adds platform-conditional profile fields and package update, pinning, and outdated commands.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.54.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.54.0
Adds platform-conditional profile fields, enabling profiles to specify different settings per platform. Not checked yet Adds package update, package pinning, and package outdated subcommands for managing package lifecycle. Not checked yet
2 details in Everything
nono v0.53.0 adds upstream TLS trust, auth interception, multi-route dispatch, and secret scrubbing from command arguments.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.53.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.53.0
Supports upstream TLS trust configuration for secure proxy connections. Not checked yet Adds interception of authentication flows in proxied requests. Not checked yet Enables multi-route dispatch for routing traffic across multiple upstream targets. Not checked yet
3 details in Everything
nono v0.52.2 suppresses save-profile prompts for denied paths
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.52.2 https://github.com/nolabs-ai/nono.git
$ git checkout v0.52.2
nono v0.52.0 adds operator-controlled variable denylisting and improved CLI diagnostics.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.52.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.52.0
Adds deny_vars field to EnvironmentConfig, letting operators block specific environment variables from being used. Not checked yet Improves diagnostics output in the CLI for better troubleshooting visibility. Not checked yet
2 details in Everything
nono v0.51.0 adds TLS interception for L7-bearing CONNECT routes in proxy mode.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.51.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.51.0
nono v0.50.0 adds env:// URI support for credential keys in custom credential profiles.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.50.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.50.0
└──▷ USE IT
Pull a credential value from an environment variable instead of hardcoding it in a profile config.
yaml
copy
credential_key: env://MY_SECRET_TOKEN
Supports env:// URI scheme in custom_credentials credential_key fields, enabling secrets to be sourced from environment variables in profiles. Not checked yet
1 detail in Everything
nono v0.49.0 adds a yaml_merge directive to the wiring system.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.49.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.49.0
nono v0.48.0 adds shell completion generation via nono completion <shell>
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.48.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.48.0
└──▷ TRY IT
Set up tab completion for nono in your shell so you can autocomplete subcommands and flags.
copy
$ nono completion bash >> ~/.bashrc && source ~/.bashrc
Adds profile subcommands to manage drafts and check package status.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.47.1 https://github.com/nolabs-ai/nono.git
$ git checkout v0.47.1
nono v0.47.0 restructures the profile JSON schema (phase 2 breaking change).
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.47.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.47.0
└──▷ BREAKING ON UPGRADE
! The profile JSON schema has been restructured (feat(profile)!): existing tooling or scripts that parse or produce profile JSON will need to be updated to match the new schema shape.
nono v0.46.0 adds GitLab domain support to the developer network policy.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.46.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.46.0
nono v0.45.0 adds native TLS root certificate support for improved PKI PKI A framework of policies, roles, and cryptographic standards for issuing and managing digital certificates that bind public keys to identities, letting tools verify authenticity and encrypt communications without pre-shared secrets. integration.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.45.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.45.0
Supports native TLS root certificates, enabling use of system or enterprise CA stores instead of bundled roots. Not checked yet
1 detail in Everything
nono v0.44.0 moves built-in profiles to the package and adds a Claude prompt to clean up old built-in hooks.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.44.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.44.0
Migrates inbuilt profiles to the package, consolidating profile management. Not checked yet Adds a Claude prompt to remove old built-in hooks, simplifying hook cleanup. Not checked yet
2 details in Everything
nono v0.43.0 adds outbound TCP TCP A network protocol that delivers a reliable, ordered stream of bytes between two endpoints. It detects lost data and retransmits it. port allowlisting and optional system keyring for headless/container builds.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.43.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.43.0
└──▷ TRY IT
Restrict a process to only make outbound TCP connections on specific ports (e.g., 443 and 8080) — useful for locking down egress in a sandboxed environment.
copy
$ nono --allow-connect-port 443 --allow-connect-port 8080 -- <your-command>
Adds --allow-connect-port flag for outbound TCP port allowlisting. Not checked yet Makes system keyring optional, enabling headless and container deployments. Not checked yet
2 details in Everything
nono v0.42.0 adds Unix domain socket allow-listing via a new --allow-unix-socket flag family.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.42.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.42.0
└──▷ TRY IT
Permit a process to communicate over a specific Unix domain socket while keeping all other traffic subject to normal policy.
copy
$ nono --allow-unix-socket /var/run/docker.sock -- my-container-tool
nono v0.41.0 enhances denial diagnostics, consolidates policy under profile, and preserves terminal scrollback on attach.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.41.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.41.0
Enhances prompts and denial diagnostics to surface clearer context when a policy blocks an action. Not checked yet Consolidates nono policy subcommand under nono profile, with nono policy retained as a deprecation alias. Not checked yet Preserves outer terminal scrollback buffer when attaching to a PTY session. Not checked yet
3 details in Everything
nono v0.40.1 adds Code URL Handler read path and improves unlink rules
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.40.1 https://github.com/nolabs-ai/nono.git
$ git checkout v0.40.1
Improves unlink rule logic Not checked yet
1 detail in Everything
nono v0.40.0 adds signed audit trails with Merkle roots, HTTP upstream reverse-proxy support, and a macOS seatbelt profile field.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.40.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.40.0
└──▷ USE IT
Apply a custom macOS seatbelt sandbox profile to tighten or loosen OS-level restrictions for a specific nono policy.
yaml
copy
# In your nono policy file:
unsafe_macos_seatbelt_rules: |
(allow file-read* (subpath "/usr/local/share"))
(deny network*)
Captures pre- and post-operation Merkle roots in the audit trail and introduces audit signing for tamper-evident records. Not checked yet Adds HTTP upstream support to the built-in reverse proxy. Not checked yet New unsafe_macos_seatbelt_rules profile field lets operators supply custom macOS sandbox (seatbelt) rules. Not checked yet
3 details in Everything
nono v0.39.0 adds OAuth2 OAuth2 An open authorization framework (RFC 6749) that lets a service grant limited access to a user's resources on another service without exposing credentials, giving cyber tools a standard way to authenticate against third-party APIs. client-credentials token exchange token exchange An OAuth 2.0 protocol extension (RFC 8693) that lets a service trade one token for another with different scopes, audience, or type, enabling delegation and impersonation across service boundaries without re-authenticating the user. with caching and a no-keychain Claude profile.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.39.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.39.0
Adds OAuth2 client-credentials token exchange with caching to the proxy, enabling automated service-to-service authentication flows. Not checked yet Adds a no-keychain profile for Claude and expands existing Claude access controls. Not checked yet
2 details in Everything
nono v0.38.0 adds package management commands, environment variable filtering, and GitLab keyless identity improvements.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.38.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.38.0
└──▷ TRY IT
Search for and install a nono package without leaving the CLI.
copy
$ nono search <package> && nono pull <package>
List installed packages or remove one that is no longer needed.
copy
$ nono list
nono remove <package>
Adds package management subcommands (pull, remove, search, list) for managing nono packages from the CLI. Not checked yet Adds environment variable filtering to control which variables are exposed in sandboxed environments. Not checked yet Prefers CI_CONFIG_REF_URI for GitLab keyless workflow identity in trust verification. Not checked yet Prints profile JSON to stdout as a fallback when saving a learned profile fails, preserving the output. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! The claude-code integration package has been removed (feat(claude-code): remove claude-code integration package).
nono v0.37.1 adds profile JSON fallback output when saving a learned profile fails.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.37.1 https://github.com/nolabs-ai/nono.git
$ git checkout v0.37.1
nono v0.36.0 adds keyring:// URI scheme for custom-service credential lookup.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.36.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.36.0
nono v0.35.0 adds GitLab ID token support for attestation and improved proxy artifact handling.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.35.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.35.0
Supports GitLab ID tokens for trust attestation workflows. Not checked yet Strips proxy artifacts and improves upstream connection handling. Not checked yet
2 details in Everything
nono v0.34.0 adds separate optional proxy settings and auto-enables Claude launch services on macOS.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.34.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.34.0
Adds separate, optional proxy settings so proxy configuration can be specified independently of other network options. Not checked yet Auto-enables Claude launch services on macOS and refines keychain access and login flow. Not checked yet
2 details in Everything
nono v0.33.0 adds Linux/WSL2 WSL2 A Microsoft-maintained compatibility layer in Windows 10/11 that runs a real Linux kernel inside a lightweight VM, letting cyber tools built for Linux execute natively on Windows without dual-booting or a full VM. GPU GPU A graphics processing unit, a processor that performs many calculations in parallel. AI workloads use GPUs to speed up model training and inference. access via --allow-gpu, a pre-flight CWD prompt for detached launches, and opt-in parent-of-protected-root relaxation on macOS.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.33.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.33.0
└──▷ TRY IT
Grant a sandboxed process access to the GPU on Linux or WSL2 without opening up the full host.
copy
$ nono run --allow-gpu <your-gpu-workload>
Adds --allow-gpu flag to enable Linux and WSL2 GPU access from sandboxed processes. Not checked yet Introduces a pre-flight CWD prompt for detached launches, surfacing working directory context before execution begins. Not checked yet Makes parent-of-protected-root filesystem relaxation opt-in via profile on macOS, replacing the previous always-on behavior. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The parent-of-protected-root relaxation on macOS is now opt-in via profile; setups that relied on this being enabled by default will no longer receive it without explicitly opting in.
nono v0.32.0 adds mTLS mTLS Mutual TLS, an encrypted connection where both client and server present certificates to prove their identity. It helps services verify who they are communicating with. client certificate support for upstream connections.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.32.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.32.0
Supports mutual TLS mutual TLS Mutual TLS, an encrypted connection where both client and server present certificates to prove their identity. It helps services verify who they are communicating with. (mTLS) client certificates for upstream connections, enabling authenticated encryption to backend services. Not checked yet
1 detail in Everything
nono v0.31.0 adds a file:// trust-key backend and --allow-gpu flag for Apple Silicon GPU GPU A graphics processing unit, a processor that performs many calculations in parallel. AI workloads use GPUs to speed up model training and inference. access.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.31.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.31.0
└──▷ TRY IT
Grant a sandboxed workload access to the Apple Silicon GPU without disabling the sandbox entirely.
copy
$ nono run --allow-gpu <target>
Adds file:// backend for trust signing keys, enabling local file-based key storage for trust verification. Not checked yet Adds --allow-gpu flag to grant sandboxed processes GPU access on Apple Silicon Macs. Not checked yet
2 details in Everything
nono v0.30.0 adds a files field for attesting arbitrary-location paths and improves NixOS compatibility.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.30.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.30.0
└──▷ USE IT
Attest a file outside standard locations by declaring it under the new files field in your trust config.
yaml
copy
# In your nono trust config:
files:
- /opt/custom/binary
- /usr/local/share/myapp/config.toml
Adds files field in trust attestation config for attesting arbitrary-location file paths. Not checked yet Improves NixOS compatibility with /nix/store path support. Not checked yet
2 details in Everything
nono v0.29.0 adds runtime and multiplexing session support.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.29.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.29.0
nono v0.28.0 adds custom CA certificate support for upstream TLS and smarter platform-specific policy handling.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.28.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.28.0
└──▷ USE IT
Route nono's proxy through a corporate or internal CA by supplying your own certificate — useful when intercepting TLS in enterprise environments.
yaml
copy
tls_ca: /path/to/corporate-ca.crt
tls_connector: custom
Supports custom CA certificates for upstream TLS connections via new tls_ca and tls_connector fields in credential/proxy config. Not checked yet Splits the Homebrew policy group into platform-specific variants for more precise sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. . Not checked yet Skips system temp grants automatically when HOME is nested under TMPDIR, reducing over-permissive policies. Not checked yet Expands recognized git config paths in policy rules. Not checked yet
4 details in Everything
nono v0.27.0 adds file-based credential sources, schema-first capability manifests, and smarter proxy tunnel blocking.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.27.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.27.0
Adds file:// credential source support in the keystore, enabling credentials to be loaded from local files. Not checked yet Adds schema-first capability manifest with --config and --format manifest flags for structured policy declaration. Not checked yet Splits Linux system groups into finer-grained categories for improved host compatibility in policy definitions. Not checked yet Auto-detects credential format from inject_header in the proxy, removing the need for manual format specification. Not checked yet Blocks CONNECT tunnels to credential upstreams and adds smart NO_PROXY handling in the proxy. Not checked yet
5 details in Everything
nono v0.25.0 adds directory exclusions for trust scanning, a seccomp proxy-only network fallback for Linux sandboxes, and per-root snapshot filters.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.25.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.25.0
Adds skip_dirs support to trust scanning and rollback preflight, letting you exclude specific directories from trust checks. Not checked yet Adds a seccomp proxy-only network fallback for Linux sandbox environments, tightening network isolation when full seccomp enforcement is unavailable. Not checked yet Adds per-root exclusion filters to the snapshot manager, enabling finer-grained control over which paths are captured during undo snapshots. Not checked yet
3 details in Everything
nono v0.24.0 adds seccomp-based network fallback for Linux sandbox environments.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.24.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.24.0
nono v0.23.1 adds --rollback-dest for directing snapshots to a custom storage path.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.23.1 https://github.com/nolabs-ai/nono.git
$ git checkout v0.23.1
Adds --rollback-dest flag to specify a custom destination directory for snapshot storage. Not checked yet
1 detail in Everything
nono v0.23.0 adds diagnostic details to path query results.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.23.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.23.0
nono v0.22.0 adds lazy verification of scan policies for faster trust evaluation.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.22.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.22.0
nono v0.21.0 adds trust policy scaffolding, startup enforcement, and a --user flag for user-level policy signing.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.21.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.21.0
└──▷ TRY IT
Sign a user-level trust policy so per-user tool permissions are enforced without requiring system-wide policy changes.
copy
$ nono sign-policy --user
Scaffolds trust policies automatically, enforces missing includes at startup, and simplifies write protection. Not checked yet New --user flag for sign-policy enables signing user-level trust policies. Not checked yet Adds standard I/O and file-descriptor paths to the base_posix policy group. Not checked yet
3 details in Everything
nono v0.20.0 adds standardized network flags with listen_port support and multi-profile extends.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.20.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.20.0
Adds listen_port flag support for controlling the port nono listens on via standardized network flag naming. Not checked yet Supports multiple base profiles in the extends field, enabling profile composition from more than one base. Not checked yet
2 details in Everything
nono v0.19.0 adds linux-arm64 support, macOS network tracing via nettop, and IPC IPC Inter-process communication, ways for separate programs to exchange data or signals. Examples include pipes, sockets and shared memory. semaphore sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. .
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.19.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.19.0
Adds linux-arm64 binary, extending nono to ARM ARM A family of RISC processor architectures designed by Arm Holdings and licensed to chip makers worldwide; tools target it to run natively on mobile, embedded, and increasingly server and desktop hardware. -based Linux environments. Not checked yet Adds macOS network tracing via nettop in learn mode, enabling automatic discovery of network activity for policy generation. Not checked yet Adds IpcMode capability for POSIX POSIX A family of standards for operating-system interfaces, including process, file and shell behavior. Software that uses these interfaces is easier to move between compatible systems. semaphores in the macOS Seatbelt sandbox, allowing sandboxed processes that use IPC semaphores to be properly profiled and contained. Not checked yet
3 details in Everything
nono v0.18.0 adds nono policy and nono profile subcommands, composable policy patches, and profile-level deny overrides.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.18.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.18.0
└──▷ TRY IT
Inspect the fully-resolved runtime policy for your current project to verify which groups and capabilities are active.
Scaffold a new custom profile interactively so you can author project-specific policy without starting from scratch.
New nono policy subcommand for introspecting the resolved runtime policy. Not checked yet New nono profile subcommand for scaffolding and authoring custom profiles. Not checked yet Adds composable policy patch configuration, letting profiles layer incremental patches on top of base groups. Not checked yet Adds extends field to embedded profiles for explicit profile inheritance. Not checked yet Adds override_deny at the profile level to carve out exceptions from deny groups. Not checked yet
+5 more
show less
Adds a default profile with base group configuration for out-of-the-box policy resolution. Not checked yet Extracts git config paths into a reusable policy group. Not checked yet Gates macOS open shim installation behind a launch services flag. Not checked yet Skips well-known heavy directories (e.g. node_modules, .git) during instruction file walk for faster trust resolution. Not checked yet Restyled --help output with grouped sections and bold headings for improved readability. Not checked yet
10 details in Everything
└──▷ BREAKING ON UPGRADE
! The security.trust_groups config field is removed; use policy.exclude_groups instead.! The base_groups field is removed; use the default profile mechanism instead.! The never_grant supervisor field is removed in favor of protected roots.
nono v0.17.1 adds a pluggable theme system with 6 built-in palettes and Landlock V6 signal scoping on Linux.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.17.1 https://github.com/nolabs-ai/nono.git
$ git checkout v0.17.1
Adds a pluggable theme system with 6 built-in color palettes for CLI output customization. Not checked yet Adds Landlock V6 signal scoping support in the Linux sandbox, tightening process signal isolation. Not checked yet
2 details in Everything
nono v0.17.0 adds a pluggable theme system with 6 built-in palettes.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.17.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.17.0
└──▷ BREAKING ON UPGRADE
! CLI flags have been standardized to verb-noun ordering; any scripts or aliases using the old flag names may break.
nono v0.16.0 adds ABI-aware Landlock sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. , external proxy bypass routing, Claude Code integration, and a swival profile.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.16.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.16.0
└──▷ TRY IT
Route a trusted internal domain directly around the nono proxy while keeping all other traffic sandboxed.
copy
$ nono run --external-proxy-bypass internal.corp.example.com -- ./my-service
Adds ABI-aware Landlock capability system for fine-grained filesystem sandboxing tuned to the target binary's ABI. Not checked yet New --external-proxy-bypass flag routes specified domains directly, skipping the sandbox proxy. Not checked yet Injects nono sandbox instructions via Claude Code system prompt, enabling automated sandbox policy enforcement in AI coding sessions. Not checked yet Adds same-sandbox process mode for signal and process-info operations. Not checked yet New built-in profile for swival applications. Not checked yet
5 details in Everything
nono v0.15.0 adds platform-aware profiles, capability elevation, Debian packaging, a built-in Codex profile, and Apple Passwords credential support.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.15.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.15.0
└──▷ USE IT
Restrict a sandboxed AI coding agent to only the privileges it needs by declaring capability elevation in your profile.
yaml
copy
# In your nono profile TOML/YAML:
capability_elevation = { groups = ["audio"] } # OS-aware; ignored on unsupported platforms
Pull API credentials from the macOS Passwords app instead of storing secrets in plaintext config.
yaml
copy
# In your nono profile, set the credential URI to an Apple Passwords entry:
credential = "apple-passwords://MyVault/OPENAI_API_KEY"
Makes the claude-code profile platform-aware, adapting behavior based on the host OS. Not checked yet Adds capability_elevation profile field with OS-aware group support for fine-grained privilege control in profiles. Not checked yet Adds Debian package support, enabling installation via .deb on Debian-based systems. Not checked yet Adds a built-in Codex profile for out-of-the-box OpenAI Codex sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. . Not checked yet Adds Apple Passwords URI credential support for sourcing secrets directly from the macOS Passwords app. Not checked yet
5 details in Everything
nono v0.14.0 adds environment variable equivalents for all CLI flags.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.14.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.14.0
nono v0.12.0 adds macOS learn mode, --net-allow override, port_allow in profiles, and context-aware sandbox failure banners.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.12.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.12.0
└──▷ TRY IT
Temporarily permit outbound network access when running a sandboxed tool that needs to pull dependencies.
copy
$ nono run --net-allow -- npm install
Lock a sandboxed service to specific outbound ports by adding port_allow to its network profile.
json
copy
{
"network_profile": {
"port_allow": [443, 8080]
}
}
Adds macOS learn mode via fs_usage that observes a process and prompts to save a generated profile. Not checked yet New --net-allow CLI flag lets users override network restrictions at runtime without editing a profile. Not checked yet Adds port_allow field to profile JSON NetworkConfig for fine-grained port-level network control. Not checked yet New context-aware diagnostic banner surfaces actionable details when sandbox failures occur. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! The Monitor strategy is removed; Supervised is now the default strategy — setups relying on Monitor will break on upgrade.
nono v0.11.0 unifies proxy and session audit trails and adds bidirectional localhost IPC IPC Inter-process communication, ways for separate programs to exchange data or signals. Examples include pipes, sockets and shared memory. between sandboxes.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.11.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.11.0
└──▷ TRY IT
Permit two sandboxes to communicate over a specific localhost port for inter-process coordination.
copy
$ nono run --allow-port 9000 <target>
Unifies proxy network audit with session audit trail for a single, consolidated view of network and session activity. Not checked yet Adds --allow-port flag to enable bidirectional localhost IPC between sandboxes. Not checked yet
2 details in Everything
nono v0.10.0 adds profile inheritance, allowed_commands, env:// credentials, and a new --override-deny flag
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.10.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.10.0
└──▷ USE IT
Reuse a hardened base profile across multiple agent configs without duplicating policy.
yaml
copy
# In your profile YAML:
extends: base-hardened
allowed_commands:
- git
- cargo
Exempt a specific deny group (e.g. a network rule) for a single run without relaxing the whole policy.
copy
$ nono run --override-deny <deny-group-name> -- <target>
Adds profile inheritance via the extends field, letting security profiles compose and reuse base configurations. Not checked yet Adds allowed_commands support to profile security config for explicit command allowlisting within a profile. Not checked yet Introduces the env:// credential scheme and GitHub token proxy support for injecting credentials from environment variables. Not checked yet Adds --override-deny CLI flag for targeted exemptions from specific deny groups without disabling the full policy. Not checked yet Removes RFC1918 RFC1918 IETF standard that reserves three IPv4 address ranges (10.x, 172.16–31.x, 192.168.x) for private networks, never routed on the public internet, giving tools a reliable way to identify internal traffic. private network CIDR CIDR A notation for a block of IP addresses, such as 10.0.0.0/24. The number after the slash says how many leading address bits identify the network. deny list from host filtering, enabling sandboxed tools to reach internal services. Not checked yet
+1 more
show less
Adds platform.claude.com to the built-in LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. APIs allowlist. Not checked yet
6 details in Everything
nono v0.9.0 adds rollback preflight with auto-exclude and walk budget controls.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.9.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.9.0
Adds claude.ai to the LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. allow list and new Landlock permissions for snapshot creation
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.8.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.8.0
nono v0.7.0 adds 1Password secret injection, Nix Darwin path support, and hard Landlock network enforcement.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.7.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.7.0
Supports 1Password secret injection via op:// URI, enabling secrets to be pulled directly from 1Password at runtime. Not checked yet Adds /nix and /run to default macOS read paths, enabling Nix Darwin environments to work out of the box. Not checked yet Enforces hard failure when Landlock network filtering cannot be applied, preventing silent sandbox escapes. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! Landlock network filtering now fails hard when it cannot be enforced; previously non-enforced Landlock would not halt execution, so setups running on kernels or configurations where Landlock network filtering is unavailable will now fail on upgrade.
nono v0.6.0 adds a network filtering proxy with credential injection, network activity tracking in learn mode, and multi-subject artifact attestation.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.6.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.6.0
Adds a network filtering proxy with host-level filtering and credential injection for sandboxed processes. Not checked yet Adds network activity tracking to nono learn, enabling discovery of outbound connections made during a learning session. Not checked yet Supports custom credential definitions in user profiles, with multiple injection modes (e.g. header, environment variable). Not checked yet Allows the sandboxed process to bind and listen on a TCP TCP A network protocol that delivers a reliable, ordered stream of bytes between two endpoints. It detects lost data and retransmits it. port. Not checked yet Supports a static proxy port for deterministic proxy configuration. Not checked yet
+1 more
show less
Adds multi-subject file attestation for companion artifact signing. Not checked yet
6 details in Everything
nono v0.6.0-alpha.2 adds Sigstore verification for instruction files, decoupled rollback, and flexible profile loading.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.6.0-alpha.2 https://github.com/nolabs-ai/nono.git
$ git checkout v0.6.0-alpha.2
└──▷ TRY IT
Use rollback independently of supervised mode to revert the last nono action.
Implements Sigstore cryptographic verification for instruction files, enabling trust validation of nono instruction sources. Not checked yet Renames undo to rollback and decouples --rollback from --supervised, allowing rollback to be used independently. Not checked yet Supports loading profiles from outside XDG XDG A set of specifications maintained by freedesktop.org that standardise where Linux applications store config, data, and cache files, letting tools respect user-defined paths instead of hardcoding locations. Home, enabling flexible configuration paths. Not checked yet Denies access to the .nono XDG directory when a user shares the HOME path, hardening the sandbox boundary. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! The undo subcommand/flag is renamed to rollback; any scripts or workflows using undo will break.! --rollback is decoupled from --supervised; previously coupled behavior may change for setups that relied on their interaction.
nono v0.6.0-alpha.1 adds human-readable timestamps to undo session listings.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.6.0-alpha.1 https://github.com/nolabs-ai/nono.git
$ git checkout v0.6.0-alpha.1
nono v0.5.0 adds Secretive, 1Password, and Go community profiles.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.5.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.5.0
Adds Secretive community profile for SSH key management sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. . Not checked yet Adds 1Password community profile for credential manager sandboxing. Not checked yet Adds Go community profile for Go toolchain sandboxing. Not checked yet
3 details in Everything
nono v0.4.0 adds Unix socket sandboxing sandboxing Running code inside a restricted environment that limits what it can access or change. The isolation reduces the impact of mistakes or untrusted code, depending on the sandbox's controls. , --exec for direct process launch, and --no-diagnostics for clean output.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.4.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.4.0
└──▷ TRY IT
Run a sandboxed process directly (no shell) while suppressing diagnostic noise — useful in CI pipelines where only the subprocess output matters.
copy
$ nono run --exec --no-diagnostics -- <your-command>
Supports Unix domain sockets in file capability rules, enabling sandboxing of tools that communicate over local sockets. Not checked yet Adds --exec flag to the run command for direct process execution without a shell wrapper. Not checked yet Adds --no-diagnostics flag to the run command to suppress diagnostic output for scripting and CI use. Not checked yet
3 details in Everything
nono v0.3.0 adds a shell command and a learn command for building allowlists from observed behavior.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.3.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.3.0
└──▷ TRY IT
Launch an interactive shell monitored by nono to capture real-world behavior.
Adds shell command for interactive shell session monitoring. Not checked yet Adds nono learn command to observe and record process behavior for policy creation. Not checked yet Adds fork+wait execution strategy with diagnostics for improved process tracing. Not checked yet
3 details in Everything
nono v0.2.6 introduces profile-driven [workdir] config and a new --allow-cwd flag
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.2.6 https://github.com/nolabs-ai/nono.git
$ git checkout v0.2.6
└──▷ TRY IT
Explicitly allow the current working directory when running nono from the command line.
Adds profile-driven [workdir] config section to control working directory per profile, replacing hardcoded CWD handling. Not checked yet Adds --allow-cwd flag to explicitly permit use of the current working directory. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! CWD handling has been removed from its previous location and replaced by the [workdir] profile config; existing setups relying on implicit CWD behavior will need to migrate to the new [workdir] config block.
nono v0.2.0 adds signed security lists and a centralized config system
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.2.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.2.0
Adds signed security lists to verify integrity of detection rule sets. Not checked yet Introduces a centralized configuration system for managing nono settings. Not checked yet
2 details in Everything
nono v0.1.1 adds var folders integration for openclaw
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.1.1 https://github.com/nolabs-ai/nono.git
$ git checkout v0.1.1
add var folders for openclaw Not checked yet
1 detail in Everything
nono v0.1.0 debuts with sandboxed AI coding-assistant control, destructive-command blocking, and keystore-backed secrets.
└──▷ GET THIS VERSION
copy
$ git clone --branch v0.1.0 https://github.com/nolabs-ai/nono.git
$ git checkout v0.1.0
Adds file-specific permission flags to enforce granular read/write/exec controls on files accessed by coding assistants. Not checked yet Steers coding assistants toward nono's policy layer, enabling policy enforcement over AI-generated actions. Not checked yet Supports inbuilt and custom security profiles for flexible, reusable sandbox configurations. Not checked yet Adds destructive command blocking with defense-in-depth protection to prevent dangerous shell operations. Not checked yet Adds secure secrets management via the system keystore, keeping credentials out of plaintext config files. Not checked yet
5 details in Everything