01
Route
Every task is scored against your policy on five axes — capability, cost, latency, reliability, and team preference — and matched to the cheapest approved model that clears the bar.
Control AI coding cost · unify developer setup
Cut AI coding spend. One setup for every developer.
Policate routes each task to a cost-efficient approved model, caps runaway context, and attributes every dollar. One managed setup delivers the approved models, tools, instructions, and guardrails.
macOS · Linux · Windows · checksum verified
Explore the product demo14-day free trial · up to 10 users · no provider usage markup
The control loop
One governed loop, from prompt to audit trail.
Policate closes the loop on every AI coding request — routing it to the right model, running it with a managed setup, attributing the spend, and enforcing policy along the way.
02
Execute
The managed binary runs the task with your approved tools, MCP servers, and context controls — capping runaway context and splitting big work into bounded worker runs.
03
Attribute
Every request is tagged to an org, team, developer, model, and work item, so cost-to-delivery is a query, not a quarterly reconstruction.
04
Govern
Budgets, residency, and tool rules are enforced before the request leaves the machine, and each decision lands in an append-only audit trail.
Start with cost
Control the four places AI coding spend escapes.
Choose a cheaper model when it is good enough, keep context from growing unchecked, stop requests at a real budget, and attach the result to the work that benefited.
Choose a lever to see a representative receipt. Values are examples; your dashboard calculates them from your own request metadata.
01 · match cost to work
Route each task to a cost-efficient approved fit.
Models & routing chooses among the eligible inventory. Policy sets the hard boundary first, then Policate scores capability, cost, latency, reliability, and team preference with an explicit fallback chain and an inspectable receipt.
route.explain.jsonexample receipt
task: refactor_authpolicy: engineering-v14sonnet: 0.94 ← selectedestimate: $0.008 vs $0.024 baselineapproved model · lower estimate
Control plane
Everything platform teams need. Nothing developers notice.
Policy engine
Versioned YAML policy for models, tools, data, teams, and budgets. Decisions are made before a request leaves the machine and every one is versioned.
# policy.yaml · v14
models: [sonnet, haiku]
budget: $2,500/mo · block over
data: eu-residency requiredIntelligent routing
Explainable scores across capability, cost, latency, reliability, and preference. Fallback chains and region controls built in.
Cost intelligence
Cost per request, routing and cache efficiency, member/project attribution, spend forecasts, smart usage signals, and hard budget blocks. Finance-ready exports for every org, team, and developer.
Approved tools and hooks
An allowlist enforced at the gateway, plus managed pre-commit and pre-push checks that travel with the binary. Every tool call is logged before execution — never after.
Provider keys
Bring your own credentials — Bedrock IAM, Anthropic, OpenAI. Recoverable provider credentials are encrypted at rest and never returned in a response; Policate API tokens are hashed.
Audit & compliance
Append-only, sealed traces with 100% coverage. EU data residency via cross-region inference profiles.
req_8f21sealed
req_8f22sealed
req_8f23sealed
More in the binary
The agent gets better tools. Your team gets lower spend.
Policate keeps the useful parts of a modern coding agent close to the developer—execution, language tooling, debugging, durable sessions, and compact context—while the router keeps each run efficient and attributable.
Code execution
Persistent Python and JavaScript evaluation for data work, scripts, and repeatable analysis without leaving the agent session.
Language intelligence
Formatting, references, and safe renames run through the project’s real language servers so edits land with their imports intact.
Debugger access
Attach to supported runtimes, inspect frames, and understand failures without turning every investigation into a print statement.
Sessions, projects, and context
Resume a named project with its policy, model mix, budget, and local receipt intact. Auto-compaction preserves the useful context before a long run gets expensive.
Cost by work item
Attribute routed spend to project, repository, branch, and developer tags so teams can see which work consumes model budget—not just which provider billed it.
GitHub + Jira context
Infer bounded repository, branch, issue, and Jira references from local metadata so cost can stay attached to a work item. This local inference is not an authenticated GitHub or Jira integration.
Choose the enforcement boundary
Start governed. Go provider-direct when the runtime is ready.
Gateway mode is the recommended starting path so controls stay authoritative on the request path. Direct mode is an explicit choice after the binary and Admin have a verified, secret-free runtime contract.
Provider-direct execution
Direct mode
The binary calls Bedrock, OpenAI, Anthropic, or your local endpoint directly. It still receives the organization’s approved models, managed tools, context controls, local role routing data, and fallback chains.
Policate binary
Local runtime
Your provider
provider connection stays in your environment
- Managed startup sync
- No provider proxy hop
- Secret-free company bundle
Centralized execution
Gateway mode
Add the Gateway when requests must pass through one authoritative layer. Policate then owns server-side policy and routing, hard budgets, redaction, exact cache, provider credentials, and request-level audit evidence.
Policate binary
Policate Gateway
Your provider
one governed enforcement hop
- Central policy and budgets
- Full cost and audit trail
- Provider credential isolation
Both modes use the same dashboard, team setup, presets, context controls, and managed startup sync. Direct keeps the data path local; Gateway adds authoritative server-side controls and complete request evidence.
Cost intelligence
See the baseline, the intervention, and the result
The dashboard separates an efficient local harness from model choice, context and compaction, exact-cache reuse, and spend prevented by a hard limit. Nothing is hidden inside a single percentage.
Illustrative monthly scenario
$3,400
34% below an ungoverned $10k/mo baseline
Harness efficiency$950
Cost-aware model choice$900
Context + compaction$850
Exact cache + limits$700
Spend, side by side
illustrative · $10k baseline−34% spend
Ungoverned
before controls
$6.6k
With Policate
after controls
Illustrative scenario, not a savings guarantee. Actual results depend on workload shape, task success, retry behavior, context growth, approved model prices, cache eligibility, and policy. Harness and routing effects are measured separately to avoid double counting.
For managers
Know who spends, why it happened, and what to change next.
Spend intelligence turns request metadata into cost per request, cache reuse, routing shifts, project coverage, and smart usage signals. It is useful for finance and platform teams without storing prompts.
Cost / request
$0.014
route to a cost-efficient fit
Cache reuse
41.8%
repeat request avoids a provider call
Harness signal
Tracked
compare successful tasks, not raw calls
Smart signal
Attribution gap
tag projects before budgets drift
Then improve developer experience
One install. One managed setup. No configuration scavenger hunt.
The dashboard publishes the approved models, policy, MCPs, skills, instructions, context controls, and Git hooks. Each developer logs in once; the binary verifies and applies the company-managed namespace on startup. User-authored content outside managed blocks stays intact, while enforced company values intentionally supersede local overrides.
The sequence advances automatically. Choose a step or pause it at any time.
policate / syncready
Every startup checks the company-managed models, MCPs, skills, commands, instructions, context controls, and hooks.
$ policate tools status
Tools Status (local vs remote)Managed revision: synced at 2026-07-17T14:22:08ZMCP Servers: ✓ github (synced)The command and output labels mirror the current CLI. Organization names, request IDs, counts, hashes, and costs are representative values.
The difference
From scattered AI spend to a single governed gateway
Without Policate
Opaque spend — no idea which team or model burns the budget
Policy lives in a wiki nobody reads or enforces
No trail — you cannot prove what ran or why
Provider keys copy-pasted into per-team .env files
Model choice is a guess baked into each codebase
Rolling out a change means chasing every developer
With Policate
GovernedEvery dollar attributed by org, team, developer, and model
Versioned YAML policy enforced before the request leaves the machine
100% append-only audit coverage, sealed and finance-ready
BYOK credentials encrypted at rest and never returned; API tokens hashed
Explainable 5-axis routing picks the best fit on every call
One policy update ships to every request, instantly
Pricing
Priced to pay for itself
Pay for the Policate control plane, not a second AI bill. Your provider charges you directly at its published rates; Policate adds no usage markup.
Team
$20
per active user / month
For teams controlling AI coding cost and developer setup.
- Gateway and Direct company setup
- Policy, routing & Gateway audit
- Exact response cache
- Budget forecasts and blocks
- Managed tools, instructions & hooks
- 14-day free trial for up to 10 users
- No markup on provider usage
Enterprise
Most controlCustom
annual, volume-based
For platform teams governing spend across the org.
- EU data residency & audit exports
- SSO, SCIM, teams, and company presets
- BYOK provider keys, encrypted
- Dedicated support & onboarding
Make the next AI request cheaper and easier to explain
Start with a 14-day trial for up to 10 users. Connect one workspace, publish the company setup, and verify the full path before rolling it out to the team.
macOS · Linux · Windows · checksum-verified downloads
Read the quickstart