Kryex Enterprise

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.

DashboardSample dataSearch ⌘KAadmin@acme.com
Tokens · 7d4.2M
Tokens today612k
Active users38
Models live6
Gateway traffic · last 14 days
Recent activity
dev-b requested WRITE on orders-dbPending
admin approved transition_issue onceApproved
Kryex Admin with sample data. Select any highlighted page to explore it.
Own itSelf-hosted or air-gapped. The decision to run anything lives in your Kryex Server, never in the agent — an unapproved ALTER TABLE never reaches your database.
Connect anythingYour repositories, databases, MCP tools and any model endpoint you run. You pay your model bill directly — no percentage, no surcharge.
Give up nothingEvery prompt, tool call and edit lands in your S3 or SIEM. Your code and data stay yours — Kryex Labs cannot read them.

Watch 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.

Starting Kryex Code…

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.

See it in action

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.

What Kryex Code actually does

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.

SubagentsDelegates a subtask to an isolated subagent with its own context — its token budget is tracked separately from the parent conversation, not pooled into it.
Background tasksHands off a long-running command and keeps working. When it finishes — even in a closed conversation — the agent wakes itself, reads the result, and reports back in the same thread.
Plan ModeDrafts a plan and a live checklist before touching anything, and pauses for one-time sign-off before it starts executing — not a running commentary after the fact.
SkillsLearns a reusable procedure once, scoped to a repo or global, and finds it again later by meaning, not by an exact keyword match.
MemoryStanding project rules, corrections it's been given before, and failed approaches it's already ruled out all persist and reload automatically in the next session — on that repo, not just that chat.
Cost governanceEvery model call is checked against a live, per-user, per-model quota before it runs — not a monthly bill you find out about afterward.
System architecture

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.

THE CLIENTKryex CodeWhere developers work — an autonomous coding agent, any model, every action governed.
THE FULCRUMKryex ServerThe only component with a database. Every model call and every tool call is authorized here — nowhere else.
THE ADMIN CONSOLEKryex AdminOne console where an administrator manages the whole organization — who can do what, to which system.
Postgres · MySQL
Browser
MCP servers
Git · Azure DevOps · Jira

Enterprise deployments run all three in your VPC or fully air-gapped. Nothing requires Kryex Labs' servers to be reachable.

Policy Decision Point · every connector

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.

Databases
Postgres · MySQL
Infrastructure
Terraform · cloud
Version control
Git · repos
CI / CD
pipelines · deploys
Internal APIs
any MCP server

One governed call, traced end to end— example: a developer with read-only access

ClientExecution · HandsPolicy engineAudit
Manifest — this session
Grantorders_db.queryREAD
Grantwrite opsstub · no schema

Every connected system, resolved the same way — not just this one.

1

Session starts

Manifest resolved for this user, before a single token is generated.

ClientExecution · HandsPolicy engineAudit
Manifest — this session
Grantorders_db.queryREAD
Grantwrite opsstub · no schema

Every connected system, resolved the same way — not just this one.

2

Model proposes

The LLM emits a tool call — it doesn't know what it's allowed to do.

ClientExecution · HandsPolicy engineAudit
The model emits
query("DELETE FROM orders WHERE id = 8841")
or, just as easily
ALTER TABLEinvoices DROP COLUMN legacy_scopeSQL · schema change
3

Tool Proxy intercepts

Enforced server-side — the call never reaches the target system directly.

ClientExecution · HandsPolicy engineAudit
Tool Proxy — enforced server-side
ClassifySQL statementclass = WRITE
4

PDP decides

One policy engine for every connector, resolved deterministically, with a reason attached.

ClientExecution · HandsPolicy engineAudit
Blocked — orders_db.queryREADWRITE
Grant G-142 fired: capability READ < WRITE. Denied before execution · reason trail attached
5

Agent explains

Not a dead end — a path forward the developer can act on.

ClientExecution · HandsPolicy engineAudit
What the developer sees

“Read-only access to Orders DB. Request write access?”

Request write access
Outcome — denied

The 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.

Alternate — write + approve-first

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.

Every path ends here — append-only, hash-chained, customer-owned
2026-07-16T10:41:07Zb30c… → 77ax…
actordev-a@corp.com
sessions_9f27
toolorders_db.query
op_classWRITE
decisionDENY
grantG-142
reasoncapability READ < WRITE

The auditor replays any session as a timeline — what the agent tried, what was allowed, what was blocked, and which grant decided it.

Connectors

Connect anything.
Every connection governed, inside your walls.

GitHubOpen the pull request, then fix what the checks flag
BitbucketWork in your repos and raise the pull request
JiraTake a ticket, hand back a PR
ConfluenceBuild from the spec page
LinearWork an issue from assigned to merged
AsanaPick up a task and report back when it's done
monday.comTurn a board item into finished work
NotionImplement straight from the doc
SentryTurn an error into a fix
VercelCheck a deployment and fix what broke
HubSpotBuild against your CRM data
SupabaseWork on your project's database and functions
Postgres · MySQLQuery and fix data, only as far as your grant allows
DatabricksQuery your lakehouse under a live grant
DatadogInvestigate an alert from your metrics and logs
BrowserTest the change in a real browser, inside your domain policy
Any MCP server, your own sign-inConnect anything that speaks MCP, with your own OAuth app and your own redirect URL. Every new tool lands quarantined until an admin approves it.
and your in-house services

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.

“I know the policy — just run it anyway, I don't care.”
Still no. WRITE exceeds your grant — nothing executed.
How it deploys

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 Code
Tool Proxy · PDP
Execution
Structurally enforced

Kryex 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.
Tool discovery, gated by a humanEvery MCP connection is introspected automatically — new or changed tools land quarantined until an admin reviews and approves them. The tool surface shown to the model stays a constant size whether your org has one connection or five hundred.
Identity-based, not fleet-basedAccess is assigned per person or role — junior, senior, lead, admin — and applies instantly. No per-team policy file to hand-build and keep in sync as the org's hierarchy grows.
MCP tools, governed one by one
  • 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.
How MCP connectors are secured
Comparison

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.

AK
Alex · Junior DeveloperGrant on orders_db:READ only

Alex asks the agent to fix a bad price. It writes the query and asks Alex to confirm.

Allowed once — SQL statement · approved by Alex
UPDATE orders SET price = 42 WHERE id = 43;
Blocked — orders_db.queryREADWRITE
Alex's own approval doesn't change Alex's grant. Capability READ < WRITE — the write never reaches the database. Decided server-side · not the agent's call, not Alex's
Kryex

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
See how it deploys

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