Docs
Palgu is the complete engineering superharness for your team's coding agents. Developers code with palgu. Every request goes through the Palgu API, where your team controls model routing, budgets and policy, with a central audit log.
Getting started
Install palgu and the coding agent with one command, then sign in. login opens a browser to approve the machine, which gets its own key (approve from any browser, so it works over SSH), and then starts a coding session in this directory (--no-start only signs in). Coding needs Node.js 20 or newer.
curl -fsSL https://api.palgu.ai/install.sh | bash palgu login # sign in, then Palgu starts here palgu -p "explain this repo" # a first task, then exit palgu # coding session in this directory palgu help # the everyday commands
Needs Node.js 20 or newer. The installer adds it if it's missing.
irm https://api.palgu.ai/install.ps1 | iex # PowerShell, no admin rights palgu login # sign in, then Palgu starts here palgu -p "explain this repo" # a first task, then exit palgu # coding session in this directory palgu help # the everyday commands
Needs Node.js 20 or newer. The installer adds it if it's missing.
Windows needs Git for Windows and Node.js 20+ (winget install Git.Git OpenJS.NodeJS.LTS).
New here? Sign up first (email one-time code; it creates your org). The Download page has Studio too. Studio for macOS and Windows.
Using Palgu inside Claude Code
palgu is its own coding CLI, and it no longer changes Claude Code's or Codex's settings. To use Palgu from inside Claude Code, install the open-source Mixture of Models mod: your session stays on your Claude subscription and the turns the mod routes go through Palgu. See Mixture of models.
claude plugin marketplace add alinaqi/mixture-of-models-claude-mod
claude plugin install mixture-of-models@mixture-of-models-claude-mod
/palgu login # inside Claude Code: sign in to Palgu
Other tools
The gateway has two endpoints: Anthropic-native at /anthropic/v1/messages and OpenAI-compatible at /v1/chat/completions. Point a tool at one of them with an srt_ key from the dashboard. Every tool, step by step: Use Palgu with your tools.
Anthropic-style tools
ANTHROPIC_BASE_URL=https://api.palgu.ai/anthropic ANTHROPIC_API_KEY=srt_xxx_yyy
aider / OpenAI-compatible clients
OPENAI_BASE_URL=https://api.palgu.ai/v1 OPENAI_API_KEY=srt_xxx_yyy
Long requests
A non-streamed call that has not answered after 45 s gets an HTTP 200 early, so the connection stays open. If it fails later, for example with a 504 timeout, the error arrives in the body, with the real status in error.status. Check the body for error on every reply, and send "stream": true for calls that can run long.
{"error": {"message": "...", "type": "server_error", "code": null, "status": 504}}
Fallback to a similar model
Every model belongs to a class: premium, frontier, workhorse, fast, image or internal. When the model serving a routed request is overloaded or down (a 429, a 5xx, a connection error, a timeout or an empty reply) before it starts answering, Palgu sends the request to the next healthy model in its fallback list, then to the cheapest other models of its class. Premium models are never added as an automatic fallback, and a reply that has started streaming is never switched to another model.
- X-Palgu-Fallback: auto: fall back as above. A pinned model (x-srooter-pin) also falls back when it is overloaded, never when the request itself is wrong (a 400 or 422, or a context-length error).
- X-Palgu-Fallback: off: no fallback for this request; the model's own error is returned unchanged.
- X-Palgu-Fallback-Models: glm-5.3,class:fast: the fallback list for this request only. Your org's model policy still applies.
- class:fast as the model name (or the pin): the cheapest healthy model of that class answers, and the rest of the class is its fallback.
Every reply says which model answered: X-Palgu-Requested-Model, X-Palgu-Served-Model and, after a fallback, X-Palgu-Fallback-Reason (for example upstream_429, upstream_5xx or timeout). GET /v1/models/health lists each model's class, whether it is healthy for your org right now and, while its circuit is open, until.
curl https://api.palgu.ai/v1/chat/completions -i \
-H "Authorization: Bearer $SROOTER_API_KEY" \
-H "Content-Type: application/json" \
-H "X-Palgu-Fallback: auto" \
-d '{"model":"class:frontier","messages":[{"role":"user","content":"hello"}]}'
Use Palgu with your tools
Code in Palgu's own apps, where every request goes through Palgu, or keep the tool you use and connect it. Tools that take a base URL use the gateway at https://api.palgu.ai/v1 with a Palgu key (srt_) from the API keys page.
| Tool | How it connects | Best for |
|---|---|---|
| palgu (CLI) | Palgu's own coding agent. Every request goes through Palgu. | Coding in the terminal with your team's routing, budgets, policy, audit and memory |
| Palgu Studio | Desktop app. Every request goes through Palgu. | Parallel tasks, council review and code knowledge in one window |
| Claude Code | The Mixture of Models mod. Critical turns stay on your Claude subscription; the rest run on Palgu. | Keeping Claude Code and spending less of your Claude usage |
| Codex | A Palgu provider and profile in Codex's config (Responses API) with a Palgu key. | Codex on Palgu's models, under your team's policy |
| Cursor | OpenAI base URL and a Palgu key in Cursor's settings. | Chat in the editor on Palgu's models |
| aider and other OpenAI-compatible tools | OpenAI base URL and a Palgu key. | Any tool that takes an OpenAI base URL |
palgu, the Palgu CLI
Palgu's own coding agent in your terminal. Every request goes through Palgu, so routing, budgets, policy, audit, code knowledge and memory apply to all of it.
Set it up
curl -fsSL https://api.palgu.ai/install.sh | bash # Windows: see Getting started palgu login # sign in in the browser; starts a session here palgu -p "explain this repo" # one task, then exit
Check it works
palgu doctor checks your sign-in, key and gateway, and says what to fix.
Limits
- Needs Node.js 20 or newer (the installer adds it).
- Want a task to run on a coding plan you already pay for? See your own subscriptions.
Palgu Studio
The desktop app: tasks as live chats, parallel work in isolated worktrees, council review and code knowledge. Every request goes through Palgu, and nothing in your shell changes.
Set it up
Download it from the Download page, open it and sign in. Then open a project folder and describe a task.
Check it works
The computer shows up on your Devices page, and your first task's requests show on your dashboard.
Limits
- Desktop only: see the Download page for the platforms.
- More in Palgu Studio.
Claude Code: the Mixture of Models mod
The open-source Mixture of Models mod (MIT) scores every prompt and keeps the critical ones in your main Claude Code session. It sends the other turns to models Palgu manages, under your org's routing, budgets, policy and audit. Your main session stays on your Claude subscription: Palgu never sees, stores or forwards your Claude login. More on the Mixture of models page.
Set it up
claude --version # mods need 2.1.287 or later; otherwise: claude update claude plugin marketplace add alinaqi/mixture-of-models-claude-mod claude plugin install mixture-of-models@mixture-of-models-claude-mod # then start claude, and inside it: /palgu login # approve the code in your browser; this computer gets its own key
The key is kept in Claude Code's secure storage and listed on your Devices page, where you can revoke it.
Routing strategies decide which turns leave Claude and which model takes them:
- complexity (the default): how much damage a wrong answer does. Security, architecture, production and anything irreversible stay on Claude.
- cost: sends more turns to cheaper models; when unsure, it scores lower.
- speed: picks faster models for shallow work.
- quality: keeps more turns on Claude; when unsure, it scores higher.
- Your own: ask Claude to use the mod's routing-strategy skill, which asks what you want to optimise and writes the strategy.
/route strategies # the built-in strategies and yours /route strategy cost # switch; remembered across sessions /route auto # score every prompt (the default) /route off # never route; everything stays on Claude
Check it works
/palgu status names your account, organisation and plan. /route says the mod is live and shows the mode (for example auto (cost)). A line under each routed answer names the model and the score, and /route stats charts your turns by model.
Limits
- A routed turn runs in a separate headless Claude Code with a short brief of your recent conversation, not its full memory. Follow-ups such as "continue" go back to your main session.
- Routed answers arrive when the turn finishes; they are not streamed.
- Your own hooks don't run in the routed turn. The mod blocks reading .env files, keys and secrets/ folders there with Claude Code's permission rules.
- Only the routed turns go through Palgu, so your policy, budgets and audit cover those turns, not the main session.
Codex
Codex on Palgu's models through the gateway's Responses API, under your team's routing, budgets, policy and audit. It uses a Palgu key, not your ChatGPT login, and only when you ask for the palgu profile.
Set it up
Create ~/.codex/palgu.config.toml. Palgu never writes it, and your ~/.codex/config.toml stays as it is.
model_provider = "palgu"
model = "<a model your org has enabled>"
[model_providers.palgu]
name = "Palgu"
base_url = "https://api.palgu.ai/v1"
wire_api = "responses"
env_key = "PALGU_API_KEY"
http_headers = { "x-srooter-pin" = "<the same model>" } # serve exactly that model
export PALGU_API_KEY=srt_... # a Palgu key from the API keys page codex --profile palgu # or one task: codex exec --profile palgu "task"
Check it works
Run codex exec --profile palgu "create hello.txt that says hi" in a scratch folder: the file appears, and the request shows on your dashboard.
Limits
- Codex 0.166 or later reads profiles from their own file. An older Codex takes the same settings under [profiles.palgu] in config.toml.
- To run Codex on your ChatGPT plan instead, leave out the profile, or let Palgu run it for you: see your own subscriptions.
With the Mixture of Models mod: its Codex guide writes the same palgu profile for you, adds Palgu memory to each prompt and continues a turn that stops mid-task.
Cursor
Cursor's chat on Palgu's models, with your team's policy, budgets and audit on those requests.
Set it up
- Open Cursor Settings, then Models.
- Under API keys, paste your Palgu key as the OpenAI API key and turn on Override OpenAI Base URL with https://api.palgu.ai/v1.
- Add a model with the name of one your org has enabled, and pick it in the chat.
Check it works
Ask something in Cursor's chat with that model selected: the request shows on your dashboard.
Limits
- Cursor sends these requests from its own servers, so it works with the cloud gateway, not one on your own computer.
- Tab completion and some of Cursor's own features keep using Cursor's models.
With the Mixture of Models mod: its Cursor guide adds Palgu memory search, sends self-contained subtasks to cheaper models through Palgu and continues a turn that stops mid-task.
aider and other OpenAI-compatible tools
Any tool that takes an OpenAI base URL: aider, Cline, Roo Code, Kilo Code, Continue, Zed, OpenHands and OpenCode. Choose the OpenAI Compatible provider, set the base URL and put your Palgu key in the tool's settings (not a file you commit).
Set it up
export OPENAI_API_BASE='https://api.palgu.ai/v1' export OPENAI_API_KEY=srt_... aider --model openai/<a model your org has enabled>
Check it works
A direct call answers, and every reply names the model that answered in X-Palgu-Served-Model:
curl -i https://api.palgu.ai/v1/chat/completions \
-H "Authorization: Bearer $OPENAI_API_KEY" -H "Content-Type: application/json" \
-d '{"model":"<your-model>","messages":[{"role":"user","content":"hello"}]}'
Limits
- Palgu serves chat completions and the Responses API on /v1. There is no /v1/models list, so type the model name into the tool.
- Your routing page shows the models your team uses.
With the Mixture of Models mod: its gateway guide has tested setups for aider, Continue and Goose that let Palgu pick the model for each request.
Not supported in front of Palgu yet: Windsurf, Gemini CLI and Antigravity. To run a Palgu task on a plan you already pay for (Claude Code, Codex, Kimi Code, OpenCode), see your own subscriptions: the vendor's own CLI runs on your machine with your login, never through the gateway.
Claude Code, Codex and other tools
Code with Palgu in palgu, its own CLI, or in Palgu Studio. Palgu no longer changes Claude Code's or Codex's settings: it does not write to ~/.claude/settings.json or ~/.codex/config.toml, so your own claude and codex keep working as you set them up.
Palgu inside Claude Code
Install the open-source Mixture of Models mod. Your Claude Code session stays on your Claude subscription, and the turns the mod routes run on Palgu's models, under your org's policy, budgets and audit. The mod can also hand a turn to Codex. Setup is in Mixture of models below.
Wiring an older Palgu wrote
An older Palgu could route Claude Code and Codex through it. The next palgu update, palgu repair or palgu login removes only the keys Palgu wrote, keeps a backup of the file and tells you how to restore it. Your own settings are never touched. palgu clients shows what it finds.
Route one session, or stop routing
palgu clients shell # routes only this session; exit to leave palgu disable # new terminals stop routing through Palgu palgu clients disable claude # removes the wiring an older Palgu wrote eval "$(palgu on)" # route this shell in place (off: restore)
A quick API check
Replace the model with one your org has enabled.
source ~/.srooter/config # loads SROOTER_API_KEY (saved by palgu)
curl https://api.palgu.ai/v1/chat/completions \
-H "Authorization: Bearer $SROOTER_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"<your-model>","messages":[{"role":"user","content":"hello"}]}'
Other tools
Cline, Roo Code, Kilo Code, Continue, Cursor, Zed, OpenHands and OpenCode: provider OpenAI Compatible, base URL https://api.palgu.ai/v1, and your srt_ key in the tool's settings (not a file you commit). aider:
source ~/.srooter/config # loads SROOTER_API_KEY (saved by palgu)
export OPENAI_API_BASE='https://api.palgu.ai/v1'
export OPENAI_API_KEY="$SROOTER_API_KEY"
aider --model openai/deepseek-pro
Not supported in front of Palgu yet: Windsurf, Gemini CLI and Antigravity. Palgu can still serve those models as backends.
Troubleshooting: a session isn't going through Palgu
Symptoms: the agent only describes edits instead of making them, your audit log shows little or no traffic, or your policies don't apply. Run palgu doctor in that terminal: it shows exactly what failed.
- Claude Code: installed, not routed through Palgu: expected. Palgu no longer routes Claude Code; use palgu, or the Mixture of Models mod inside Claude Code.
- gateway probe: FAIL (401): your key is invalid or expired. Run palgu login again, or paste a fresh key with palgu repair --key-stdin (hidden input).
- A local model-routing wrapper that hands coding to another CLI competes with Palgu: turn it off in that repo. The mixture-of-models mod is the exception: its routed turns go through Palgu by design.
Mixture of models: Claude for critical turns, Palgu for the rest
Already pay for a Claude subscription? The open-source mixture-of-models mod for Claude Code keeps your main session on Claude and hands the low-risk turns to cheaper models through Palgu. Those turns then get Palgu's routing, budgets, policy and audit, and your Claude usage goes to the work that needs it.
How it decides
- Scores every prompt. A 1 to 10 blast radius (how much damage a wrong answer does) and a task kind. A local Ollama model scores for free; otherwise Claude Haiku on your plan.
- Keeps critical work on Claude. Security, architecture, production incidents and anything irreversible (8 and above by default) run in your main session, exactly as before.
- Sends the rest through Palgu. A routed turn runs in a separate headless Claude Code whose environment alone points at Palgu, on the model your routing strategy picks (complexity, cost, speed, quality or your own; /route strategies lists them). Your main session is never re-pointed.
- Falls back safely. If the child fails, or its answer is a hand-back, an unverified claim or a request for you to act, the main session answers that turn instead. Follow-ups such as "continue" always return to the main session.
- Shows where each turn ran. A line under every answer names the model and score; /route stats charts your turns by model.
Set it up with Palgu
Mods need Claude Code 2.1.287 or later. Install the mod:
claude --version # 2.1.287 or later; otherwise: claude update
claude plugin marketplace add alinaqi/mixture-of-models-claude-mod
claude plugin install mixture-of-models@mixture-of-models-claude-mod
Then start claude and sign in to Palgu from inside it. The mod shows a link and a short code; approve it in your browser (a new account then chooses a paid plan). This computer gets its own key, listed on your Devices page, and the mod keeps it in Claude Code's secure storage.
/palgu login # sign in or sign up, and connect this computer /palgu status # who is signed in, the organisation and its plan /route # where your turns run
How it compares with the other tools: Use Palgu with your tools.
Palgu no longer points your main Claude Code session at a gateway, so there is nothing to undo first. If an older Palgu wired it, palgu repair removes that wiring once, with a backup. Source, privacy notes and the full configuration: github.com/alinaqi/mixture-of-models-claude-mod (MIT licence).
Your own subscriptions: Claude Code, Codex, Kimi Code, OpenCode
Already pay for a coding plan? Run a Palgu task on it. Palgu starts that vendor's own CLI on your machine, in the task's folder, logged in by you. Palgu never sees, stores or forwards your login or token, and the CLI talks to its own vendor, never through the Palgu gateway. Palgu's routing, model groups and per-token cost don't apply to that part, because your plan pays and the CLI picks its models.
- Claude Code: palgu --runner claude -p "task". Log in once with claude auth login.
- Codex: palgu --runner codex -p "task". Log in once with codex login.
- Kimi Code: palgu --runner kimi -p "task". Log in once with kimi login.
- OpenCode: palgu --runner opencode -p "task". Log in once with opencode auth login.
palgu runners # what this machine can use: installed, version, login, terms palgu runners --json # the same, for scripts and Palgu Studio palgu --runner auto -p "fix the failing test" # the first one you're logged in to
Cursor: coming once its terms check passes
The Cursor runner is built in but stays off until Cursor confirms that Palgu may run it on your browser login. Until then, palgu runners shows Cursor as disabled and says why. Once it is on, Palgu runs Cursor's documented print mode (cursor-agent -p) with Cursor's sandbox on, so commands stay in the task's folder, on the browser login you make with cursor-agent login. Palgu never passes a Cursor API key.
OpenCode
OpenCode is open source, and the plan belongs to the provider you logged in to. Palgu runs it when OpenCode is logged in to ChatGPT Plus/Pro, GitHub Copilot or OpenCode Go, whose owners allow their plans in OpenCode. Anthropic allows Claude Pro/Max only in its own apps, so if OpenCode holds a Claude Pro/Max login, palgu runners shows OpenCode as disabled and says why. Remove that login with opencode auth logout, or run the task on your Claude plan with palgu --runner claude.
OpenCode is disabled while it also holds an API key, because OpenCode picks which login a run pays with: remove the key with opencode auth logout. Cursor and OpenCode don't run in CI (when CI is set).
Palgu Flow on your subscription
Palgu Flow can run its implementation work on your plan too. Flow still plans the task, writes the failing tests, runs them, checks ownership and merges; only the turns that write the implementation (and repair it) run on your CLI, in the lane's own folder. Flow judges that work exactly as its own: changing a test, editing files outside the todo, or committing gets the turn rejected. The tests, checks, review and merge stay on Palgu.
palgu flow run "add a CSV export" --runner codex palgu flow run "add a CSV export" --runner auto --on-subscription-limit palgu
Make it the default in ~/.srooter/settings.json, or for one project in .srooter/flow.json: {"flow_roles": {"implementer": {"runner": "codex", "on_subscription_limit": "stop"}}}. A project file is used only when it was written on your machine: one tracked by git came with the repository and is ignored, so a repository can't spend your plan. If the CLI isn't installed or logged in, Flow says so and uses the gateway. When the plan runs out, the run pauses until it resets (resume with palgu flow resume <id>), or with --on-subscription-limit palgu the gateway finishes it. The lane shows where it runs, for example "implementing on codex (your subscription)".
When a plan runs out, the task stops and shows the reset time. With --on-subscription-limit palgu, Palgu finishes it on the gateway instead and says so. Your organisation can turn subscription runners off in its policy.
Build an app on Palgu
Your app can use Palgu as its single key: users sign in with Palgu, approve your app once, and your app calls the gateway with a key that can do only what they approved. Their organization's budgets, policies and audit apply, and they can revoke your app at any time. Mixture of Models and ideavalidator work this way.
1. Register your app
An organization admin registers the app on the Your apps page under Team rules, or with POST /admin/org-apps. An app you register works only inside your organization: only its members can approve it, and everyone else sees it as not available. An app meant for every Palgu organization is registered by Palgu's admins. You choose:
- Client ID: 3 to 32 characters of a-z, 0-9 and -, for example acme-notes. It is unique across Palgu and cannot change later. Ids that start with a reserved name (palgu, our earlier product name, studio, claude, anthropic, openai, chatgpt, codex, gemini, google, grok, xai, microsoft, github, cursor, mcp) are refused.
- Name and publisher: what users see on the consent screen, "Allow Acme Notes by Acme Ltd".
- Homepage, repository and icon: https links only.
- Scopes: what your app needs, from the table below. Ask for the fewest you can.
- Public or confidential: an app that runs on users' machines is public and gets no secret. A server-side app can be confidential and gets a client secret.
New apps start as unverified: the consent screen warns users and asks them to confirm twice. Your organization's own apps also say "Registered by your organization" and always stay unverified; Palgu verifies only apps it registers for everyone. An organization can have 20 apps that are not revoked, and register up to 10 an hour.
2. Choose scopes
A key your app receives can reach only the endpoints its scopes name. Anything else answers 403 with "error": "insufficient_scope" and the scope it would need, and Palgu adds new endpoints to the list explicitly.
v1:chatSend chat requests to models. /v1/chat/completions, /v1/responses, /anthropic/*, POST /v1/pricing/quotev1:researchRun grounded web research. /v1/researchcouncilAsk the model council. /v1/council/*imagesGenerate images. reserved: no endpoint yetprofile:readSee your name, email and organisation. GET /meAny key may sign itself out with DELETE /me/devices/current.
3. Sign users in with the device flow
- POST /auth/device/code with your client_id and a device (name, os, arch, client_version and a random install_id that stays the same for this install). You get a user_code, a verification_uri_complete and an interval.
- Show the code and open the link. The user signs in at palgu.ai/connect, sees your app, its publisher and scopes, and chooses Allow.
- Poll POST /auth/token every interval seconds. authorization_pending means keep waiting, slow_down means add 5 seconds, and access_denied or expired_token means stop. A confidential app also sends client_secret.
- The answer carries access_token (an srt_ key for this install), the granted scope, the gateway URL and the user's organization. Keep the key in the OS keychain, never in a file you commit.
An unknown, suspended or revoked client_id gets invalid_client. Leave out scope to get every scope your app registered, or send a space-separated scope that is a subset of them (for example a read-only sign-in with profile:read); the consent screen then lists only those. Asking for a scope your app was not registered with is invalid_scope. If an admin removes what you asked for before you collect the key, the poll answers access_denied: start the sign-in again.
Quickstart: Python
import time, uuid, requests
GW, APP = 'https://api.palgu.ai', 'your-client-id'
device = {'name': 'my-laptop', 'os': 'macOS', 'arch': 'arm64',
'client_version': '0.1.0', 'install_id': str(uuid.uuid4())}
start = requests.post(f'{GW}/auth/device/code',
json={'client_id': APP, 'device': device}).json()
print('Open', start['verification_uri_complete'], 'and approve', start['user_code'])
interval = start['interval']
while True:
time.sleep(interval)
r = requests.post(f'{GW}/auth/token', json={
'grant_type': 'urn:ietf:params:oauth:grant-type:device_code',
'client_id': APP, 'device_code': start['device_code']})
body = r.json()
if r.ok:
break
if body['error'] == 'slow_down':
interval += 5
elif body['error'] != 'authorization_pending':
raise SystemExit(body['error']) # access_denied, expired_token
key = body['access_token'] # store it in the OS keychain
reply = requests.post(f'{GW}/v1/chat/completions',
headers={'Authorization': f'Bearer {key}'},
json={'model': 'glm-5.3',
'messages': [{'role': 'user', 'content': 'hello'}]})
print(reply.json()['choices'][0]['message']['content'])
Quickstart: TypeScript
const GW = 'https://api.palgu.ai', APP = 'your-client-id'
const post = (path: string, body: object) =>
fetch(GW + path, { method: 'POST', headers: { 'content-type': 'application/json' },
body: JSON.stringify(body) })
const device = { name: 'my-laptop', os: 'macOS', arch: 'arm64',
client_version: '0.1.0', install_id: crypto.randomUUID() }
const start = await (await post('/auth/device/code', { client_id: APP, device })).json()
console.log('Open', start.verification_uri_complete, 'and approve', start.user_code)
let interval = start.interval, key = ''
while (!key) {
await new Promise((r) => setTimeout(r, interval * 1000))
const res = await post('/auth/token', { client_id: APP, device_code: start.device_code,
grant_type: 'urn:ietf:params:oauth:grant-type:device_code' })
const body = await res.json()
if (res.ok) key = body.access_token // keep it in the OS keychain
else if (body.error === 'slow_down') interval += 5
else if (body.error !== 'authorization_pending') throw new Error(body.error)
}
const res = await fetch(GW + '/v1/research', { method: 'POST',
headers: { authorization: 'Bearer ' + key, 'content-type': 'application/json' },
body: JSON.stringify({ query: 'Who sells usage-based billing for AI apps?' }) })
console.log((await res.json()).sources)
4. Call the gateway
- Chat (v1:chat): POST /v1/chat/completions, OpenAI-compatible, or /anthropic/v1/messages. Palgu routes each request to a model the organization allows.
- Pin a model: send x-srooter-pin: <model> to get exactly that model instead of routing. If the organization's policy does not allow it you get a 403, never a substitute.
- Research (v1:research): POST /v1/research with {"query": "..."} returns an answer with its sources.
- Council (council): POST /v1/council/deliberate asks several models and returns each verdict plus the chair's synthesis.
- Who is signed in (profile:read): GET /me.
Rate limits and budgets
Every request counts against the user's organization: its budget and rate limits apply to your app as they do to everything else, and its admins see your app's requests and spend on their own line (GET /admin/apps/usage). An organization that runs out of balance gets 402 with billing_error; too many requests get 429 with Retry-After. Back off, show the message, and do not retry in a tight loop.
An organization can also give your app its own limits: a number of requests a minute and a monthly budget, for that organization only. Over the rate, your app gets 429 with code: app_rate_limited and Retry-After. Over the budget, it gets 402 billing_error with reason: app_budget until the next month or until an admin raises the cap: nothing is served in its place. Both errors carry a docs link to this section.
Revocation
- A user can revoke your app on their Authorised apps page. That signs it out of every device they use it on.
- An organization admin can block your app for the whole organization. Its keys stop at once and new sign-ins there are refused.
- Palgu can suspend or revoke an app for everyone.
In each case your key starts answering 401 within seconds. Treat a 401 as signed out: delete the stored key and offer to sign in again.
Worked examples
- Mixture of Models (client_id mixture-of-models, scopes v1:chat profile:read routing:read council work:read tickets:read memory:read): a Claude Code mod that signs in with the device flow, then sends its routed turns to /anthropic and prices each one with /v1/pricing/quote.
- ideavalidator (client_id ideavalidator, scopes v1:chat v1:research profile:read): signs in the same way, then calls /v1/research for cited market research and /v1/chat/completions with a JSON schema for each stage.
Registry API reference
Every change is recorded in the audit trail. A client secret is returned once, by create or rotate, and Palgu keeps only its hash. The org-apps routes need an organization admin's dashboard session and the x-csrf-token header (from GET /admin/csrf); the platform routes are for Palgu super admins.
GET /admin/org-apps # org admins: your organization's apps POST /admin/org-apps # register; "confidential": true for a secret PATCH /admin/org-apps/{id} # edit name, publisher, links, scopes POST /admin/org-apps/{id}/status # {"status": "active" | "suspended" | "revoked"} POST /admin/org-apps/{id}/rotate-secret # a new secret; the old one stops now GET /admin/platform/apps # every app POST /admin/platform/apps # register; "confidential": true for a secret PATCH /admin/platform/apps/{id} # edit name, publisher, links, scopes, verified POST /admin/platform/apps/{id}/status # {"status": "active" | "suspended" | "revoked"} POST /admin/platform/apps/{id}/rotate-secret # a new secret; the old one stops now GET /admin/apps/{id}/org-control # org admins: this org's block PUT /admin/apps/{id}/org-control # {"blocked": true} signs the app out of the org GET /admin/apps/usage # org admins: requests and spend per app GET /me/apps DELETE /me/apps/{id} # a user's authorised apps, and revoke
What's new
Jul 2026 · new model
Kimi K3 (kimi-k3), Moonshot's flagship, now routable
2.8T params, up to 1M context, native visual understanding. In our agent-build benchmark it scored 8/8 with 5/5 UI polish, matching Opus, Fable, and GPT-5.6-sol. It used the fewest iterations and cost ~$3.60/build: half of Opus, a third of Fable. Of the nine models tested, it is the lowest-cost model with a 5/5 UI score. See the benchmark →
Palgu Studio, the desktop app
palgu> Studio is a macOS app for coding through Palgu. It needs no environment changes, runs TDD with functional and visual validation by default, and gives the agent your code graph for project context. Every request goes through the gateway (routing, budgets, policy, audit). Signed and notarized, for Apple Silicon and Intel.
↓ Download for Mac
Everything in one window
- Tasks point at a project, describe what you want; an agent works it as a live chat, streaming its progress and asking before write and shell actions. Run several in parallel (shared tree or isolated worktree).
- Sessions your past agent sessions, grouped by day; resume one where it left off.
- Knowledge the cortex code graph plus Mnemos session records. The graph indexes when you open a project, so the agent starts with a map of the code. Refresh the Agent Codemap here too.
- Council five models review a change using SOLID, C4, OWASP and the Test Pyramid. You see their findings and disagreements, and can challenge a finding.
- Reviews paste a GitHub PR link (or review your local diff) for a grounded council review.
- Routing see which model each tier routes to and why (read-only; edit on the web dashboard).


New here? Download Studio or the CLIs, then sign in: the in-app Getting started guide walks through your first task.
The Palgu CLI
Run palgu to open a coding session in your project, or palgu -p "…" to run one task and exit. It replaces claude or codex in your workflow. The coding agent talks only to your Palgu gateway, so routing, budgets, policy, audit and cortex apply to every request. palgu checks the agent against a signed release before every run, and palgu update updates it.
palgu # interactive session in this directory palgu -p "summarize src/index.ts" # one task, then exit (CI-friendly) palgu --continue # continue your last session palgu resume [<id>] # continue a paused task (the newest, or <id>; a Flow run id resumes that run) palgu --fast "<task>" # speed mode: the quick profile, checkpoints kept (/fast in a session) palgu --continue-claude # pick up a Claude Code session (--continue-codex: Codex) palgu code [--] <args…> # pass any other agent flag through unchanged palgu review [base] [--yes] # council review; exit 0 approve, 1 changes requested palgu doctor # check the agent, clients and your key
Unknown words are never guessed as a prompt: palgu fix the test stops and suggests palgu code -p "fix the test". palgu help lists the everyday commands, palgu help all every one, and every command takes --help. Settings come from flags, then env (SROOTER_URL, SROOTER_MODEL, and SROOTER_PROJECT for the cortex project to ground in), then ~/.srooter/config, which login writes.
Permissions: read-only tools always run; write and shell tools prompt for approval in a session ([y] once, [a] always, [n] deny). In non-interactive runs they are denied unless you pass --dangerously-allow-all.
Speed mode
Speed mode is for small, low-risk work you want done fast: a prototype, a page, a fix. Add --fast to the command you already use. There are no flow words to learn, and the old spelling, palgu flow run --speed-mode "…", still works.
palgu --fast "add a footer"One task in speed mode, then exit. --speed is the same flag.palgu -p --fast "fix the date format"The same, as a headless one-shot (scripts, CI).palgu --fastAn interactive session whose tasks run in speed mode./fast [on|off]In a session: switch speed mode for the next tasks (no argument toggles it).palgu resume <flow id>Continue a speed run that paused (the id is in its pause line).What it changes
- The quick profile: the task runs the fewest steps that still build it test-first, on a 15 minutes budget (time waiting for you at a checkpoint does not count).
- Checkpoints kept: in a terminal the run still stops for you at the spec checkpoint and the plan checkpoint. Speed mode never turns on autopilot; a non-interactive -p run keeps the usual rules (your org's signed policy decides).
- Never past the guardrails: high risk work (auth, payments, data, deploys) and your org minimum still win. Palgu then says speed mode off: high risk (…) or speed mode off: org minimum standard and runs the safer profile.
- A failed check pauses, it does not fail: the pause line names the next step, for example palgu resume f-20261105-a1b2c3.
The model group in force
Each speed run says which model group serves it, for example ⚡ speed mode · model group: Speed-first, at the start and in the run summary, and the flow roles line names it too. The group is your project's, else your team's, else your org's, as set on Routing; model group: none (custom routing) means the routing matches no single group. For the fastest runs pair speed mode with the Speed-first group.
Tasks from AWG
AWG, the Agentic Work Graph, is a shared task list for coding agents and people: each task has a state, acceptance criteria, dependencies, a lane, who holds it and the evidence that proves it is done. It is Palgu's task list: Palgu shows your tasks on the web, in Studio and in the terminal, and only Flow runs write to it.
Hosted AWG, on by default: one workspace per project
Every Palgu organization gets hosted AWG, run by Palgu, with nothing to set up: no admin step, no token to paste and no Connect AWG screen. Each Palgu project gets one AWG workspace of its own, created automatically the first time the project is created or opened, in Studio (macOS and Windows), palgu or Flow. Opening the project again never makes a second one, and existing projects get theirs too. While a workspace is being made, the project's tasks show Setting up and the project keeps working locally; if AWG is down, Palgu makes it later. Palgu signs in to each workspace for each person with their own Palgu sign-in and the narrowest access the view needs, so a member removed from the organization loses access to its tasks.
Settings, Integrations, Tasks reads Tasks: hosted AWG (default) and lists each project's workspace with its state and Open in AWG; one that couldn't be created has Retry. Palgu stores only the ids that tie a project to its workspace, never a token.
Use your own AWG (self-hosted, org admins)
Only for an organization that runs its own AWG. An org admin opens Use your own AWG in Settings, Integrations, Tasks; Palgu then reads tasks from it instead of hosted AWG. Members see which AWG is in use; only admins can change it.
- Token: in AWG, mint a workspace-wide token of kind reviewer, the lowest privilege AWG offers. Palgu refuses a token that can write, claim or administer AWG, because it only reads.
- Fill in the AWG address (https, on the public internet), the workspace and the token, then Test connection: every check runs and nothing is stored. Connect stores it only when every check passes.
- Link projects: pick the AWG project for each Palgu project. Palgu suggests links where the repositories match.
- Later: Test connection again, Rotate token, or Disconnect (the project links are kept; revoke the token in AWG too).
Paste the token only into the card's password field, never into a chat, an issue or the assistant. The gateway stores it encrypted and shows only its last 4 characters.
Where tasks show
Every view reads the same tasks through your gateway, so no laptop or browser holds an AWG token, and every view starts with the tasks that need you.
- Web: Tasks in the dashboard: the counts, Needs you, then Board, List or Tracks. Open a task for its acceptance criteria, dependencies, checks with their evidence, handoffs and its proof of done.
- Palgu Studio (macOS and Windows): Tasks in the sidebar for every project, Tasks on a project's page, and a Tasks card in Mission Control.
- Terminal:
palgu tasks listThis project's tasks: state, id, title, lane, who holds it, proof. The ones that need you come first.palgu tasks show <ID>One task: acceptance criteria, dependencies, checks and evidence, the latest handoff.palgu tasks lanesThe named lanes and the parallel tracks AWG computes.palgu tasks summaryCounts by state, ready to claim, running, needs you.Proof of done reads the same everywhere: Verified done, Done (no proof required), Checks passed, Proof pending, Check failed, Proof is for an older commit, Needs review. AWG decides when a task is done; Palgu shows it.
Flow on AWG
On by default on hosted AWG. Turn it off for a run with PALGU_AWG=0, or for a project with {"awg.enabled": false} in .srooter/settings.json. A Flow run writes its plan's todos to AWG, claims each todo before it builds it (so no todo is built twice), and posts the test, validation and visual evidence. On hosted AWG it signs in with your Palgu sign-in; on your own AWG it uses your AWG agent credentials, never the org's reviewer token. When AWG can't be reached, the build goes on and the writes replay later.
When there are no tasks to show
A view that can't show tasks says why in one line, never as an error:
No tasks yet: start a task and Palgu tracks it hereHosted AWG: nothing has been tracked for this project yet. Start a task or a Flow run.Tasks need AWG. An org admin can link your own AWG in Settings → IntegrationsThis gateway has no hosted AWG and your organization has no AWG of its own.This project's tasks are being set upHosted AWG: the workspace for this project is being created. The project works locally meanwhile; the tasks show up on their own.This project isn't linked to AWG yetHosted AWG on a gateway that doesn't create a workspace per project yet. Flow runs keep their todos locally until then.Tasks are pausedHosted AWG didn't accept your Palgu sign-in. Sign in to Palgu again; if it keeps happening, contact support.This project isn't linked to an AWG project yetYour own AWG only: an org admin links it under Link projects.Tasks are paused until an admin reconnects AWGYour own AWG only: it refused the stored token. An org admin rotates it.Tasks aren't enabled on this gatewayThis gateway runs without Tasks.Moving from Conductor Cloud: Transfer to local
A Conductor Cloud workspace becomes a hosted Palgu workspace: its tasks, lanes and proof live in your organization's hosted AWG workspace, its code knowledge in cortex, and its repository, settings and members in the Palgu project. You can see it on the web, in Studio and in the terminal.
Where the agents run: Palgu doesn't offer hosted agent compute (Conductor's cloud machines) yet. Your agents run on your own Mac or PC, logged in to your own Claude Code, Codex or OpenCode (Cursor: coming once its terms check passes), while the state is hosted. Palgu never holds, proxies or replays a subscription token.
- 1. Export from Conductor. Before Conductor Cloud goes read-only, right-click each workspace and choose Transfer to local, or use Settings → Account → Export data for everything. Keep the archive.
- 2. Install Palgu on your Mac or PC. Palgu Studio (macOS and Windows) or the palgu CLI. Sign in to Claude Code, Codex or OpenCode as you do today: tasks run on your own subscription. Cursor: coming once its terms check passes.
- 3. Import the archive. palgu import conductor --archive <export.zip> --json > import.json lists what it found and changes nothing until you apply it.
- 4. Create the hosted workspace (not available yet). Once the import lists your Conductor Cloud workspaces, palgu hosted create --from import.json shows what it would create and --yes creates the Palgu project and its hosted AWG workspace. Run in your local copy of the repository (or with --repo <dir>), it also adds a task for each Conductor task; running it again creates nothing twice. This version of palgu import conductor --archive doesn't list them yet, so today it creates nothing.
- 5. Index the code. palgu memory index . in the repository puts its code knowledge in cortex for everyone on the team.
- 6. Check it. palgu hosted lists each imported workspace: project, AWG workspace, tasks in AWG and cortex. The web shows the same under Settings, Integrations, Tasks.
Only ids, task titles, branches, pull request links and counts are sent to Palgu. Chats stay read-only history on your machine; their text is never uploaded. Members join through your Palgu organization, not from the export.
Agents: watch them live
Every agent Palgu runs (the session's main agent, the agents it starts, lanes and threads) shows in one view, grouped the same way everywhere: Needs you, Working, Ready and Done. Each row has a mark and a word for its state (never colour alone), what it is, the model it runs on, what it has cost with the agents it started, and what it is doing.
○ queuedWaiting to start, with the reason (memory, capacity, budget or the org limit).● workingRunning now.▲ needs youWaiting on you: a question, a spent budget, a failure, or no update for a long time.‖ pausedPaused by you or with the agent that started it.◦ idleIts turn is over; the result is ready to review or merge. Or it waits for a plan or a top-up, with a Top up or Choose a plan link.✓ done · ✗ failed · ■ stoppedFinished. A failed agent says why in plain words, with Retry.Where agents show
- Terminal: palgu agents on this computer, where you can peek, reply, stop, pause, resume and raise a budget. palgu agents --all-devices shows every device.
- Palgu Studio (macOS and Windows): Agents in Mission Control, with the same actions for agents on this computer.
- Web: Agents in the dashboard shows your agents on every device, read-only: filter them (s:needs_you, a:reviewer, d: device, p: project) and open one for its details. An org admin sees the organization's agents and whose each one is.
You stop, pause or message an agent on the computer that runs it, in Palgu or Palgu Studio. The gateway keeps only states, numbers, the model and a one-line summary with secrets removed, plus the device and project folder name. The transcript, your messages, report text, labels and pins never leave that computer.
Coming from Conductor
Open a Conductor repository in Palgu and it runs as it did: same scripts, same variables, same ports (ten ports per worktree). Then bring your workspaces over with one command, which shows a dry run first. The story, the dates and a side-by-side are on Move from Conductor.
palgu import conductor --dry-runA dry run (also the default): every change the import would make, and none made.palgu import conductor --applyMake them. Run it again and it has nothing to do.palgu import conductor --path ~/code/appOne repository, wherever its worktrees are.palgu import conductor --archive export.zipConductor's Settings → Account → Export data archive: chats become read-only task history.palgu workspace run [<action>]A run action from .conductor/settings.toml, in this terminal (the default one without a name).palgu workspace setup | archive | actions | envSetup again, Archive, the action list, the variables a script gets.Your settings work as they are
- Read natively: .conductor/settings.toml (with settings.local.toml over it) or the older conductor.json. Setup, named run actions, Archive, run_mode and environment_variables.
- The same variables: CONDUCTOR_WORKSPACE_PATH, CONDUCTOR_ROOT_PATH, CONDUCTOR_WORKSPACE_NAME and CONDUCTOR_PORT, the first of 10 ports kept for each worktree, plus PALGU_* twins. The agent's shell gets them too.
- Files to copy: .worktreeinclude, else your patterns, else .env*, into each new worktree; a file already there is never overwritten.
- Run mode: with run_mode = "nonconcurrent", starting an action stops the one running in another worktree first.
What the import does
- Each worktree becomes a task, in place, on its branch. Nothing is moved, and uncommitted changes stay as they are.
- Notes and PRs: the worktree's .context notes become the task's handoff, read first when it resumes; its open pull request is linked when gh is signed in.
- MCP and env: .mcp.json and your env variables are read where they are; nothing is copied.
- Secrets: the values in settings.local.toml go to the macOS Keychain or Windows Credential Manager as the project's secrets, never into a file. Studio's rules decide which reach tasks: one that looks like production (a LIVE or PROD name, a live key) waits until you classify it. On Linux the import lists them for you to add in Studio.
- Safe: it never deletes or changes Conductor's data or your worktrees, and never touches your Claude Code or Codex settings. Applying it again is a no-op.
Agents and modes
- Your own subscription: each agent runs through its own CLI, logged in on your machine. palgu runners lists the ones this machine can use, and palgu --runner claude -p "..." runs a task on one.
- Instructions and tools: CLAUDE.md, AGENTS.md, skills and .mcp.json are read as they are.
- Conductor chats: continue a Claude Code or Codex session with palgu --continue-claude or palgu --continue-codex.
Command reference
Slash commands (in a session)
/helpList every command./model [id]Show or switch the active model./contextToken usage and spend for this session./configShow the resolved gateway, key and model./doctorCheck the gateway is reachable and your key works./clearClear the on-screen transcript./cortex Search your org code graph over the gateway./review [base]Send the branch diff to the multi-model review council./loop Run a task autonomously, heartbeat-bounded./monitorLocal sessions, token totals, spend, scheduled count./schedule …add / list / rm cron-scheduled prompts./workflow Run a multi-step JSON workflow (steps as sub-agents).Flags (after palgu code)
--continueResume the latest session.--model Pick the model for this run.--gateway Override the gateway URL.--pinServe the requested model verbatim (skip routing), for benchmarks.--max-turns Cap autonomous turns.--dangerously-allow-allSkip permission prompts (unattended / CI).Autonomy and orchestration
- /loop <task> runs a task autonomously. After each turn the gateway heartbeat decides whether the agent stopped prematurely and should keep going, injecting its nudge as the next turn. The gateway enforces a per-session budget and a limit of 25 iterations.
- Sub-agents the model can call run_subagent to delegate a focused subtask to a fresh child agent: its own context, the same tools, one level of nesting (no recursion). The child is non-interactive, so side-effecting tools only run when the parent granted allow-all. Use sub-agents for focused research or independent tasks.
- MCP (on by default) configure servers in ~/.srooter/mcp.json (user) and .mcp.json (project). Their tools load automatically as server__tool, permission-gated like any write tool. A broken server is logged and skipped, never fatal.
Ops, scheduling and workflows
palgu code monitor # sessions, token totals, spend, scheduled count palgu code schedule # fire any due scheduled tasks once (cron tick) palgu code schedule run # foreground scheduler: tick every minute palgu code workflow wf.json # run a multi-step workflow
- /schedule add <m h dom mon dow> :: <prompt> · list · rm <id>. Stored in ~/.srooter/agent/schedule.json; fire them with schedule (one tick, wire to system cron) or schedule run (foreground).
- /workflow <file> a JSON of steps { name, steps: [{ id, prompt, dependsOn? }] }. Steps run in dependency order (independent steps in a level run concurrently); a step prompt can reference an earlier step's output with {{stepId}}. Each step runs as a sub-agent.
Cortex and review
- Cortex the model can call a search_cortex tool that queries your org's code graph over the gateway, so it grounds in real symbols, not just local grep. /cortex <query> runs it directly. Needs an indexed project (SROOTER_PROJECT).
- Review palgu review [base], or /review in a session, sends your committed branch (from the merge-base with origin/<default branch>, or the base you give) to the gateway's multi-model review council and prints the verdict with file:line findings. It lists the files and bytes and asks before sending. .env*, *.pem, *.key, *secret* and id_rsa* files are never sent, and the diff is capped at 120,000 characters. The council reads the diff; it does not run your code. See Palgu review.
Routing rules
Palgu classifies every request into a tier and routes it to the model assigned to that tier. You configure the assignments in your dashboard. Defaults:
trivialCommits, formatting, housekeeping → cerebras (fast, cheap).substantiveThe main coding tier → glm (the everyday workhorse).long_contextConversations over the token threshold (default 60k) → glm.thinkExplicit extended-thinking requests → deepseek-pro.architecture / securityHigh-stakes intents → the council chief (claude-opus).Change them in your dashboard at Models & routing: pick the model per tier, the intent-classifier model, the council members, and the long-context threshold. A live preview scores your config on speed, cost and quality and the blended $/1k tokens, with a baseline comparison against running one frontier model for everything. Changes apply to new requests; reset to Palgu defaults anytime. Hard caps (model allowlists, max reasoning effort, speed tier) live under Models & routing → Model rules.
Cortex code graph
Cortex is an iCPG (intelligent code property graph), your org's knowledge of its own code: symbols, dependency edges, and intent pulled from docstrings. Once a repo is indexed, coding sessions answer "where is X" from the graph, and coding sessions and risk reviews use it to see what a change touches.
palgu memory index . # index this repo (project auto-detected) palgu memory index . --force # force a re-index palgu doctor # check your setup
Once a repo is indexed, coding sessions in palgu keep its index fresh. Palgu no longer adds an auto-index hook to Claude Code.
Browse it in your dashboard at Memory: find a project, ask questions and get answers that cite their sources, explore the architecture level by level (modules, files, symbols), and read the intent behind the code (why it exists, recorded or inferred, with sources).
Agent Codemap
A CODEMAP.md is a machine-first map an AI agent reads first to orient in a repo: what the system is, where things live, how a request flows, and the invariants not to break, instead of burning dozens of tool calls crawling the tree. Where AGENTS.md and CLAUDE.md give the agent the rules, the Codemap gives it the map. Palgu generates it from your code graph, and --check flags a stale map. It is plain Markdown, so any agent can read it (Claude Code, Codex, Cursor, Windsurf, OpenCode).
palgu memory codemap . # preview a fresh map (stdout) palgu memory codemap . --write # write / refresh CODEMAP.md palgu memory codemap . --check # validate anchors + freshness (exit 1 on error) # also: /codemap in a Palgu session, Studio Knowledge Refresh CODEMAP.md
The generator owns the deterministic sections (architecture, module map, danger zones) and drafts the rest with confidence markers for you to curate. --check gates writes and runs on session start, so a stale or broken map is caught, never silently trusted. See ADR-067.
Skills
Skills inject your engineering practices into the model, per intent. Palgu ships four default skills:
tdd-enforcerStrict TDD: RED, GREEN, VALIDATE, with 80% coverage minimum.security-baselineNo hardcoded secrets, parameterized queries, bcrypt/argon2, input validation.quality-gatesMax 20 lines/function, 3 params, 2 nesting levels, 200 lines/file.python-conventionsType hints, Pydantic, pytest, ruff plus mypy, pathlib.Skill-aware routing: for one-shot tasks such as a slide deck, dashboard, landing page or polished doc, routing can add a matching skill and upgrade the model for that request. Define your own org-wide skills (name, directive, intents, soft or hard enforcement, priority) at Standards & skills, and personal ones, layered on top of org policy, never overriding governance, under Mine on the same page.
Session memory
Mnemos is Palgu's working memory per coding session. For Anthropic-format traffic it records the session's opening request, the files it edited or wrote, and tool errors, and it checkpoints them as the session gets long. Today it is a record for you to inspect: its content is not added back into your agents' requests.
Inspect it in your dashboard at Sessions → Memory: sessions with their latest checkpoint (goal, active constraints, a fatigue score) and the typed nodes (Goal · Constraint · Error · Decision · Result).
Risk reviews
Risk reviews catch changes that touch sensitive surfaces: auth, tenant scoping, secrets. A fast guard model scores each change out-of-band; when the score is high, a frontier reviewer model (claude-opus) checks the approach and adds corrective guidance to the agent's next turn. Risk reviews do not block the developer.
Review events in your dashboard at Security reviews: each shows a severity, the findings (which dimensions fired, with evidence), the corrective guidance, and buttons to mark the outcome (confirmed / incident / dismissed / trivial) so the threshold tunes to your codebase.
Sign up and start coding
Sign up with an email code and your org is created. Then run palgu login, and each request gets an audit record. See Privacy for what is stored, and for how long.
Get started →