pal.

A system to control your coding agent's scripting.
More autonomy, fewer prompts, more security.

A coding agent writes and runs code on your machine, with your credentials. Mostly it does the job. Occasionally it does more: an API key written somewhere it doesn't belong, a commit nobody asked for, a destructive call on a token that happened to have root.

pal ensures all your agent's actions are held to a task-specific policy you agree on ahead of time, with no means to circumvent it.

github.com/brownsys/palsgraf

Installation

$ curl -fsSL https://example.invalid/install.sh | sh
Installs pal 0.4.2, released
Supported Platforms: Linux (x86_64, aarch64) · macOS (aarch64) · manual install

Setting up: To protect a project with pal, run pal init in its root directory. This interactively integrates pal with the agent harness (supported are Claude Code, opencode and pi).

Help us improve pal by reporting any issues on GitHub or sending experience reports to justus [at] brown [dot] edu.

What it can do

With pal you can deploy machine-global policies, and you can also use the built-in policy authoring tool together with your agent to write task-specific ones — so you can step away from the churning agent with confidence. Some examples of what is possible:

File permissions

global
Allow it access to your project (./), but disallow writing your .bashrc or reading your .ssh.
task-specific
For your “fix my merge conflicts” prompt, the agent proposes “edit access only to what's in git status” as a temporary grant.

Specific API verbs

global
Restrict the agent to read-only GitHub API access during planning.
task-specific
You prompted “review this PR”, and the agent proposes the permissions CREATE_REVIEW_COMMENT(owner=me, repo=my-repo), CREATE_PR_REVIEW(owner=me, repo=my-repo), …

Command restrictions

Force your agent to use uv for python dependency management by allowing access to dependency storage locations and network only to the uv command.

Limitations

Is one of these a blocker for you? Tell us in an issue.

How it works

No way around it

pal runs all your agent's system access through a sandbox and observes its network traffic via a proxy. Only effects that are policy compliant are allowed.

The policy is yours

A .pal/policy.toml in your project says which paths the agent's work may write and which hosts it may reach. The agent can propose a change and you approve or refuse it; it cannot edit the file directly. See writing policies.

Made for your agent

pal is a single-binary MCP server that replaces your bash tool. Simply run pal init to configure it and set a first policy. It automatically teaches your agent how to create policies collaboratively.

State

pal is a research prototype and we are eliciting feedback on the ergonomics of the policy authoring workflow and compatibility with tasks people care about. Let us know if anything doesn't work for you or your agent by filing an issue on GitHub.

Writing policies

A policy is a TOML file. pal init leaves a sensible baseline in your project's .pal/policy.toml — writable paths, reachable hosts — and everything the agent's work touches is checked against it as it runs.

The policy is yours to edit, but you can leverage your agent for more convenience. The agent can't change the policy, but it can suggest a change which you review and approve or deny. You would see a dialogue like this:

The agent is asking to change what pal scripts may do here.

Agent's reason: I need the closed issues for this milestone to write the changelog.
  • allow network requests to api.github.com

Applies until this pal server exits; your policy file is not changed.

This dialogue is natural language, but generated by pal, not by the agent. You can trust its accuracy. Your approval and denial also goes directly to pal, all facilitated by trusted MCP protocol provisions.1 Agent's can request temporary allowances for the current session or you can ask them to permanently edit your policy.

The pal language

pal init also sets up a new programming language, pal, which runs alongside bash and enforces policies directly in the interpreter. The language is comparable to a simplified python, but every external effect is enumerable, explicit and checked against the policy.

$ pal -c 'fn main() {
    let pat = re.compile(r"https?://\S+")
    let matches = pat.scan(fs.read("notes.md"))
    for m in matches { stdout.write(m.group(0)) }
}'

This is one of the shell forms. Your agent also has access to it through an MCP server. Both are bounded by the same policy.

Telemetry

With the pal front end, each script run emits one structured record to stderr (also mirrored to a local JSONL file) — outcome, error kind, source hash, model name.

Upload them with pal telemetry collect when you've got a few. You can review (and edit) the exact data before it's sent. We use this information to make the language more useful; pal telemetry collect --help spells out what gets shared.

Telemetry collection for sandboxed agents is currently supported only for Claude Code. More platforms coming (next planned is Copilot).

Manual install

The curl | sh line on the install card downloads the right prebuilt binary for your platform, verifies its checksum, drops it into ~/.local/bin, and installs the action catalog policies draw on. If you'd rather see what's happening before running it — or you're on a platform we don't ship a binary for (Intel Mac, Windows, BSD) — here's the same thing, by hand. Either way, run pal init in a project afterwards; that is what connects pal to your agent.

Option A: prebuilt binary

Pick the asset matching your platform from https://pub-c19bb22cdb2d42909de545e416be1e90.r2.dev/latest/ — currently pal-linux-x86_64, pal-linux-aarch64, or pal-darwin-aarch64. Each has a sibling .sha256 file with its checksum.

$ ASSET=pal-linux-x86_64   # adjust for your platform
$ curl -fsSL -o pal        "https://pub-c19bb22cdb2d42909de545e416be1e90.r2.dev/latest/$ASSET"
$ curl -fsSL -o pal.sha256 "https://pub-c19bb22cdb2d42909de545e416be1e90.r2.dev/latest/$ASSET.sha256"
$ sha256sum -c pal.sha256  # or `shasum -a 256 -c` on macOS
$ chmod +x pal
$ mv pal ~/.local/bin/

Option B: build from source

If you'd rather build, the same source tarball our release pipeline uses lives next to the binaries. Needs a Rust toolchain (install via rustup.rs) but no submodule fetch or workspace setup. Swap the path segment for v0.0.0 (or whichever) to pin a different version; the tarball is named after the same segment.

$ curl -fsSL https://pub-c19bb22cdb2d42909de545e416be1e90.r2.dev/latest/pal-src.tar.gz | tar xz
$ cd pal-*-src
$ cargo build --release -p pal
$ cp target/release/pal ~/.local/bin/