Own your software development lifecycle. Connect anything. Give up nothing.
Self-hosted in your VPC or fully air-gapped. Connect your repositories, databases, tools and models; Kryex Code does the work, Kryex Admin decides who can do what — and every action is checked before it runs, inside your walls.
orders-dbPendingtransition_issue onceApprovedWatch Kryex refuse a call it isn't allowed to make.
Maya asks Kryex Code to fix a customer record in production. Her access is read-only, so Kryex Server refuses the write, even when she says try anyway. Kryex asks her admin for access; the admin grants it but holds every call for approval, and the change runs only once they approve it.
Maya's Kryex Code is the real app replaying a recorded session. Sam's Kryex Admin is a separate screen: every grant and approval happens there, on the admin's own machine.
Kryex Code and Kryex Admin, working together.

It plans first.
A live checklist, sign-off before it touches anything — not commentary after the fact.
It delegates.
Subtasks run in isolated subagents, each with its own tracked budget — never pooled into yours.
It remembers.
Project rules, past corrections, approaches it's already ruled out — reloaded automatically, next session.
It never holds the keys.
The decision to reach a database, an MCP tool, or run a command lives only in Kryex Server — never in the agent's own process.
A real coding agent underneath the enforcement.
Not a policy layer with a chat window attached to it. Kryex Code plans, delegates, remembers, and runs work on its own — the same execution boundary just applies to every one of these, the same way it applies to a single tool call.
One system, three parts. All of it runs inside your walls.
Kryex Code, Kryex Server and Kryex Admin all deploy in your own infrastructure — in your VPC or fully air-gapped. Kryex Server is the only part that makes an authorization decision and the only one that writes the audit log. Kryex Code never holds a credential or a decision; it only acts on what the server allows.
Enterprise deployments run all three in your VPC or fully air-gapped. Nothing requires Kryex Labs' servers to be reachable.
The ALTER TABLE. The rm -rf. The prod deploy.Resolved through one policy engine, every time.
Every tool call Kryex Code makes — database, MCP, infrastructure, deploy — resolves through one policy engine on the server before it runs. Not application logic to trust, not a wrapper the agent can talk its way around. Shell commands are checked against the same policy engine, against an admin-set, default-deny shell policy.
One governed call, traced end to end— example: a developer with read-only access
Every connected system, resolved the same way — not just this one.
Session starts
Manifest resolved for this user, before a single token is generated.
Every connected system, resolved the same way — not just this one.
Model proposes
The LLM emits a tool call — it doesn't know what it's allowed to do.
query("DELETE FROM orders WHERE id = 8841")Tool Proxy intercepts
Enforced server-side — the call never reaches the target system directly.
PDP decides
One policy engine for every connector, resolved deterministically, with a reason attached.
Agent explains
Not a dead end — a path forward the developer can act on.
“Read-only access to Orders DB. Request write access?”
Request write accessThe write never executes. Credentials live in the vault and the decision is enforced server-side — no config to edit, no key to steal. The refusal is data the model can explain, not an opaque error.
If the grant included WRITE with the approve-first modifier: the proxy holds the call, a team admin gets it in their approvals inbox, and on approval the proxy executes with vault credentials — the result streams back into the same session. The agent waits. The developer does nothing special.
The auditor replays any session as a timeline — what the agent tried, what was allowed, what was blocked, and which grant decided it.
Connect anything.
Every connection governed, inside your walls.
Every connector runs through the same grants, approvals and audit log. How connectors are secured
Tell it to do it anyway.It still won't.
This isn't a suggestion the model can talk itself out of. The policy gate enforces the boundary server-side, before the command runs — not a warning after the fact, not a setting a prompt can argue past.
Kryex is the agent. There's no other path in.
No separate client to trust, no config pointing somewhere else — Kryex already is the client, so every read, write, and execute already runs through the same gate before it happens.
Kryex CodeKryex is the agent
- For
- Teams adopting Kryex as their coding agent, not bolting it onto an existing one.
- Setup
- Nothing to configure — Kryex already is the client.
- Enforcement
- Structural. Every read, write, and execute passes through Kryex's own Tool Proxy → PDP before it runs.
- Changed tools are pulled automatically. If an MCP tool's definition changes, it's taken out of use until an admin re-approves it.
- Approval holds the actual call. “Requires approval” holds the call itself until an admin approves, then runs exactly that call.
- Org-wide control per tool. Allowed, Needs approval, or Blocked for everyone. Destructive tools need approval by default.
- People connect their own accounts. GitHub, Atlassian and more, as personal connectors. Every call runs as them; the org decides which tools are allowed.
Most tools govern the model call or ask the user to approve. Kryex also checks the grant at execution.
Most of what the market calls “governance” is a tool asking its own user for approval. The user is still the one deciding. Kryex checks the grant, not the consent — and it holds even when the user says yes.
Alex asks the agent to fix a bad price. It writes the query and asks Alex to confirm.
UPDATE orders SET price = 42 WHERE id = 43;
One agent, not bolted onto another
Self-hosted, one policy, built as its own coding agent from the ground up.
- Grant-checked, not consent-checked — approval never overrides the grant
- One grant model, across every connected system
- One audit trail you own, not one per vendor
Every other gateway governs the model call. Kryex owns the agent that makes it — so the check happens where the action actually happens, not one layer removed from it.
Reviewed October 2026, based on vendors' public docs. Reflects each vendor's own public docs and product announcements as of this writing, not aspirational roadmaps on either side. Governance is improving everywhere — the gap is that it stops at each vendor's own boundary.
Own your software development lifecycle. See it on your own systems, with the team that builds it.
Get started on your own.
Try Kryex Code free on your own machine today. Bring your team onto Kryex Enterprise when you're ready.
Start for free