Control: permissions, policies, budgets, sandbox, audit
The agent is the executor, the decisions are yours. Pulse gives five levels of control: from a question for each action to a strict prohibition, which is not bypassed by auto mode.
1. Permissions
When an agent wants to write a file or execute a command, a card pops up on top of all windows: what tool, what command, what files. Options:
- Allow - once;
- Allow in session — this tool no longer asks in this session; from a command the rule takes a program and a subcommand (
npm test) and acts only on a single command - there is no chain, writing to files and code by the interpreter; above such a command there is a summary “Writes ... · Runs ...”; - Reject - the agent will be refused and try differently.
The card does not block the rest of the application: you can look at a diff or another task and return to the answer.
2. Auto mode
The "Permissions" chip in chat switches the session to Auto: Pulse responds to requests after policies are applied. The adapter remains in permission request mode. Native permission bypass modes (bypass, yolo, acceptEdits, never) are blocked. The entry “Allowed by auto mode” remains in the activity feed.
Auto mode can also be enabled for all new agent sessions (in his card) or agent variant.
Important: politicians are stronger than the auto regime. What is prohibited by a rule remains prohibited, and an explicit “Ask” rule requires a human response.
3. Politicians
Settings → Policies. First, the rules are ordered by the accuracy of the place of action (the task is more precise than the profile and role, those are more accurate than the agent, the agent is more accurate “everywhere”), within one accuracy - from top to bottom; The first one that comes up solves:
| Field | What does it mean |
|---|---|
| Action | Allow · Ask · Deny |
| Tool | Bash, Write, Edit, Read...or * for everyone |
| Template | regular expression by command, paths and call header (case insensitive) |
| Where it works | everywhere · specific agent · agent variant · role in the swarm · one task |
| Explanation | why the rule is needed - visible in the feed and in the audit |
Disabled by default: deleting root and home folder (rm -rf /), forced
git push --force, commands from root (sudo), working with disks (mkfs, diskutil erase,
dd), and files with secrets (.env, .pem, id_rsa...) require confirmation.
In addition to the rules role: Swarm members with a reviewer role (analyst, security, product) cannot edit files or run commands at all.
Organization File: Central Policies and Offline License
The rules above are configured on the machine, which means they are weakened on it. For teams with security requirements this is not enough, so there is signed organization file
pulse-org.json. It lies in the Pulse data folder (Settings → Help → “Data folder”) and carries two things: policy rules and an offline license for a closed circuit, where there is no Internet and logging into your account is impossible.
The procedure for solving the file:
ban and "ask" from the organization file ← cannot be relaxed on the machine
↓
your rules (task → profile/role → agent → general)
↓
permissions from the organization file ← your ban is stronger: stricter - you can
↓
ask (regular thread)
The file is visible to humans: Settings → Policies → “Organization file” shows who issued it, who issued it, until what date it is valid and what rules were added. A rejected file is shown with a reason - it does not silently disappear. The rules from the file in this list cannot be changed or turned off, and in the feed and in the audit the decision on them is signed “organizational rule”, and not just “rule”: a person will correct his rule himself, but this will not be corrected.
As long as there are no trusted keys in the assembly, no organization file will be accepted. List
TRUSTED_ORG_KEYSinsrc/main/orgBundle.tsempty - and in all current Pulse builds it is empty. Anypulse-org.jsonwill be rejected with a direct reason: “there are no trusted organizational keys in this Pulse build - there is nothing to check the file with.” This is not a breakdown, but a consequence of the fact that trust is set during assembly (see below): for the mechanism to work, you need its own assembly with its own key. Tacit trust in any file sent would be worse than no verification.
How to start it. The signature key is issued by the owner; the private key is not included in the repository (org-keys/ and *.key.pem closed .gitignore):
node scripts/sign-org-file.mjs keygen --id osminog
The script will print the public key and the finished string for TRUSTED_ORG_KEYS in
src/main/orgBundle.ts. The key fits during assembly intentionally: the key that the application would read from the data folder or from the environment variable would be replaced by the same person from whose indulgences the file is protecting. After editing - the usual Pulse assembly.
The contents of the file are regular JSON, terms can be written as dates:
{
"org": "Octopus LLC",
"issuedBy": "admin@osminog.ru",
"expiresAt": "2027-01-01",
"license": { "plan": "enterprise", "expiresAt": "2027-01-01", "key": "ORG-0001", "seats": 50 },
"policies": [
{ "id": "no-curl", "action": "deny", "tool": "*", "pattern": "curl\\s", "note": "Internet access is prohibited" }
]
}
node scripts/sign-org-file.mjs sign org.json --key org-keys/osminog.key.pem --id osminog
node scripts/sign-org-file.mjs verify pulse-org.json --pub org-keys/osminog.pub.pem
Ready pulse-org.json placed in the Pulse data folder on each machine and distributed in any usual way (GPO, MDM, simply by copying). There can be one section: only rules or only license - a file without both is rejected because it does nothing, but would appear valid in the interface. One corrupted rule rejects the entire file: silently throwing out the rule from the centralized ban is exactly the weakening that the file protects against.
The new file is picked up on its own, without restarting: the state is remembered by time and file size, and the policy page rereads it every time it is opened.
What does the license from the file provide? In a closed circuit, where there is no Internet at all, it replaces logging into your account. There are two sources of rights, and the one that works is more important: a rejected or expired file does not take away the rights of the person who logged into the account, and an unsuccessful login does not take away the rights of the circuit without a network. An expired file does not provide any license or rules.
What the file doesn't do
- Doesn't respond. There is no revocation mechanism: the released file is valid until its due date. There is only one way to revoke it - remove the key from
TRUSTED_ORG_KEYSand build a new version of Pulse, that is, immediately devalue all files signed with this key. - Doesn't get attached to the device. The file contains neither a machine identifier nor a link to an account: copied to any computer, it operates there.
- Doesn't count jobs.
seats- a certificate for a person, the application does not count places and does not prohibit anything based on them. - Does not protect against clock changes. There is no server in a closed circuit, there is nowhere to take the lower time limit except the release date of the file itself. Pulse will notice a clock set to a date earlier than the release (“the clock on the computer is behind: the organization’s file was issued later than today’s date”), and any date between the release and the deadline will be accepted as real - that is, the deadline of the file on a machine without a network is deceived by setting the clock back.
- Does not centrally close anything except policies and licenses. The sandbox and access to the network from it, auto mode, budgets and limits, the list of MCP servers remain machine settings: there are no fields or checks for them in the file. You can limit the agent's commands and file edits from the center, but you cannot prevent the agent from turning off the sandbox.
- Does not replace the application signature. A person with administrator rights on his machine can replace Pulse itself - the assembly signature and the order of its installation protect against this.
The rules of the organization live separately from yours: in pulse-settings.json they are not saved, they are not involved in transferring settings between machines, and on each machine they are taken from its file. The "organization rule" mark cannot be entered into the settings manually - it is only added by successful signature verification.
You can check the mechanism without rebuilding only when running from source:
PULSE_ORG_KEY_FILE=org-keys/osminog.pub.pem PULSE_ORG_KEY_ID=osminog npm start
In the assembled application, these variables are not read. The path to the file itself can be overridden by a variable PULSE_ORG_FILE — it is always readable and convenient for testing on a live assembly.
4. Budgets
Right there, block "Budget":
- Limit per task, USD — the total cost of all its sessions;
- Limit per task, tokens — the total consumption of all its sessions in tokens;
- Warn at, % — a notification arrives at this threshold;
- When any of the two session limits are exhausted, tasks stop, new turns are not started until the limit is raised (in the task header or in the settings).
The cost is visible at every turn, in the task chip and on the dashboard. An unknown price is not considered zero. The USD limit reacts after the provider’s report; it does not guarantee a payment ceiling. In dialogue Time and limits You can separately limit the number of turns and total minutes of agents. The queue checks limits - money, tokens and turns - before each turn, time - every second. The refusal states the reason (“Token limit: 92 / 50”), not just “budget exhausted.” The token limit, like the monetary limit, is triggered by a report usage after a turn: a turn that has crossed the threshold has already been made, the next one will be stopped. Deleting a session does not reset the budget. More details: Project Dimensions.
Separate budget for H200 manifest swarm
The limits described above apply to desktop Pulse tasks. Scheme
AgentTaskManifest in packages/pulse-core sets a different budget for the future batch swarm: maxToolCalls, maxMinutes, maxRetries and stopCondition. Now it's the turn to perform maxRetries and transfers permission to the handler
beforeToolCall(). First role request in
packages/pulse-agents includes stopCondition in prompt and is interrupted by
maxMinutes; This is a limitation of one request, not all turns of the problem. The queue stores the already accepted number of calls in the payload of the next attempt: a regular retry does not reset maxToolCalls. There is no working tool manager that calls access to each tool yet. Repeated delivery of the same attempt after a process crash also does not save the counter, so this is not yet a hard limit for the task. The stopping condition is passed to the model as an instruction and is not checked by the machine. For complete restriction, you need a local-executor with checking for each tool and a stable counter for the entire session (#246, #335).
Why is there a limit in tokens?
Not every agent tells you the price. U local model and GigaChat it doesn’t exist at all: the expense there remains unknown, not zero, and the money limit never works. These agents always report tokens - for them, the limit in tokens is the only one that works. Previously, it was possible to limit their consumption only indirectly, by the number of turns and minutes.
Consumption in tokens is calculated according to reports usage, and its accuracy is different - the product shows it, not hides it:
| Agent | What's coming | As shown |
|---|---|---|
| Local model, GigaChat | tokens of the request itself (prompt + response) | exact number: 1.2 million |
| Claude Code, Codex, Kimi, OpenCode | busy context snapshot | rating: ≈ 260 thousand |
Estimation - because each turn re-sends the entire context: the sum of the snapshots is close to the expense, but is not an exact measure. If no one reported some of the token turns, “part of the turns without reporting” is added to the number, and the lower limit is written as “from.” If not a single turn is measured, it is written: “the consumption in tokens is unknown.” Zero instead of ignorance is never shown.
Your swarm limit
Block "Swarm Budget" — a separate account of the swarm participants.
A swarm of six participants eats up the entire task limit, and stopping the overall limit hits all sessions of the task at once, including the one in which you are working. Therefore, the swarm has its own limits - in dollars and in tokens - and its consequences:
- open swarm tasks are canceled, the swarm pauses;
- swarm members' sessions are stopped;
- task sessions outside the swarm continue to work - your work is not interrupted.
Empty fields mean that the swarm does not have a separate limit and its consumption is counted only in the general task limit. The task limit remains the main one: if it is exhausted, the entire task, including the swarm, is stopped.
5. Sandbox
Teams bash built-in agent (“Local Model”) are executed through sandbox-exec
macOS. There are two restrictions, and they are enabled separately - block "Sandbox" in “Settings → Policies”:
| Switch | What does | Default |
|---|---|---|
| Local model commands in sandbox | writing is allowed only in the worktree of the task, in the temporary folder and in the caches of package managers; reading is not limited | included |
| Accessing the network from the sandbox | disabled - the command will not open a connection to the outside and will not resolve the domain name | turned on, that is, the network is open |
You can almost always limit recording, but the network cannot: they don’t work without it npm install,
pip install and git fetch. Therefore, the network is open by default and is closed deliberately - where the agent has nothing to do on the Internet, and especially the worktree content. This is the only thing that prevents an agent with a local model from taking a working copy outside: such an agent does not have its own sandbox, it executes commands itself.
The network ban lives inside the sandbox profile. If the sandbox itself is turned off, there is nothing to prohibit - the network switch is then unavailable and is signed by this.
What a network ban does not promise
It closes outgoing connections of the command itself and its descendants - and only them. Deliberately left open:
- loopback (
127.0.0.1,::1) - the dev servers and tests of the project live on it, for the sake of which the sandbox is kept turned on. Fee: A local proxy with access outside the sandbox is still achievable; - unix local services sockets — without them, docker, local databases and some assemblies break. The payment is the same: the service, which itself goes to the network, remains reachable;
- macOS system services. Checked: from the sandbox, the command dials LaunchServices, that is, it can ask the system to open a link (
open https://…) - the browser will start outside the sandbox. If it's important, close itopenandosascriptpolicy rule: rules are checked earlier and stronger than the sandbox.
Name resolver (mDNSResponder) is closed separately: the DNS request takes away the data in the subdomain name no worse than HTTP. localhost at the same time it continues to be resolved - it gives it away
/etc/hosts, not a resolver.
Linux and Windows
On Linux, the built-in agent sandbox uses bubblewrap (bwrap). Recording and network switches are available, but the effect of the sandbox depends on the system: before the first command, Pulse checks with a test record that bwrap really limits access. If
bwrap is missing or user namespaces are prohibited, the command runs without a sandbox, and the reason is written to the application log. Details and restrictions - in
platform descriptions.
On Windows there is no sandbox for the built-in agent yet: both switches are unavailable. Teams are not limited to a recording or network sandbox; Policies and “Ask” mode are in effect.
External agents (Claude Code, Codex, Kimi, OpenCode) work in their own sandbox - the one provided by their developer.
6. Audit
Button "Audit" in the task header, uploads the report to exports/:
- who launched the tools and when, with what arguments;
- what permits were issued, by whom (human or auto) and which were rejected;
- what policy rules worked - and whose: yours or the organization’s;
- section "Parcels": what went to another person for this task and what came back. There is also a disclaimer that there is no parcel delivery in the product and Pulse does not know who the file went to (see. Collaboration);
- what files are affected, how many tokens and money were spent.
The file is a regular Markdown: it can be attached to an incident analysis or to a report to the customer.
How does it fit together?
tool request
│
├─ ban from the organization file ────► refusal (not weakened on the machine)
├─ policy: Deny ────────────► refusal (auto mode will not save)
├─ reviewer role and file editing ────► refusal
├─ task budget is exhausted ─────────► all task sessions are stopped
├─ the swarm’s budget is exhausted ────────────► only the swarm is stopped
├─ policy: Allow ────────────► running
├─ auto mode or “allow in session” ► running, recording to tape
└─ otherwise ──────────────────────────► permission card for you
Decisions not covered by this document
Everything above is about control inside the application: what the agent can do on your machine and how to check it. There is a second type of solution that doesn’t come down to settings: they change what outsiders see. Open part of the code, create a public repository, ask for money - this is not checked and is not done along with refactoring.
These solutions look into docs/decisions/ - separately for each: what will change, what it will cost in work and risk, what will become irreversible and what question the owner must answer. What has been verified there is separated from assumptions, and where facts do not decide, so it is written: the rule “Pulse does not tell a person what it does not know” also applies to notes about the future, and not just to the interface.
There are three open entries: catalog library/ separate repository,
public code mirror and
file FUNDING.yml.