NewPlan Mode, subagents & memory — now in Kryex Code

Ship real work with an agentthat can't go around you.

Kryex Code plans, delegates, and remembers — and still can't go around you.

Claude Opus 5.5, Sonnet 5.5 and Haiku 5.5 included free — no API key needed.Deploys into your VPC or fully air-gapped. Your models, your logs, your walls.

New sessionledger-api

Start a task

Describe what you want done — the agent reads, edits, and runs commands in your workspace, with approval on anything risky.

Pick a task to watch it plan, write, and run the fix. Every call is authorized against your live grant — anything beyond it is denied with a stated reason, never run silently.

Bring your own model

Bring the model you already trust — through your own endpoint or gateway

AnthropicOpenAIGeminiMistralLlamaDeepSeekMoonshotAWS BedrockAzure AI Foundry
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.

Blocked before it runsThe agent's own process never holds the decision. The ALTER TABLE never reaches your database.
Any model, no markupPoint it at your own endpoint or corporate gateway. You pay your model bill directly — no percentage, no surcharge.
Audit you ownEvery prompt, tool call, and edit lands in your S3 or SIEM. Kryex Labs cannot read it.
Connectors

Connect your tools once.
The agent works across all of them, governed.

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

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.

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
Pricing

Start free. Bring it inside your walls when you're ready.

Free
$0

The full agent on your own machine, with Claude Opus 5.5, Sonnet 5.5 and Haiku 5.5 included free — no API key needed.

GPTClaudeGeminiMistralQwen Coder+ more
Download Kryex Code
Enterprise
Customfor your organization

Self-hosted or air-gapped, RBAC with grants, approve-first sign-off, live quotas, the admin console, and an audit trail you own. Runs only the models you connect, inside your walls.

Talk to us

Bring your own key anytime — Kryex never marks up your provider's bill. Compare plans

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.