Kimchi Workspaces

    Move your agents off the laptop. Into a governed runtime.

    Persistent cloud machines for coding agents. A template decides which agents run, which tools ship, and what the network allows. Credentials are injected into requests as they leave - the agent never sees them.

    Book a demoRead the docs
    workspace-7f2a - template: backend-goRunning
    terminal 1 - kimchi
    $ kimchi "refactor auth middleware"reading internal/auth/middleware.goplanning edits across 6 files...edit 1/6 - token check extracted
    terminal 2 - agent cli
    $ agent-two "write tests for auth"middleware_test.go - 3 casespassing - same policy as terminal 1
    egress: allowlistcredentials: gateway-injected4 vCPU / 8 GBapi key provisioned at creation
    Isolated cloud machineProvisioned from templatesSecrets never touch the disk
    Why workspaces

    A developer laptop is not a runtime.

    Coding agents run with your developers' credentials, on their machines, with access to everything the laptop touches. Security notices and blocks the tool. The agent was never the problem. Where it runs is.

    No isolation

    An agent with full autonomy has full access - files, sessions, the VPN, everything the laptop can reach. One prompt is all it takes.

    Secrets on disk

    Agent CLIs authenticate with tokens in dotfiles and env vars. Any agent can read them. There is no boundary between the agent and the credential.

    No egress control

    Nothing decides which services an agent may reach, or records what it called. The first incident is how you find out.

    Admin controls

    One template. Every workspace, governed.

    An admin builds the template once: which agents run, which tools ship, the compute, the network policy. When a developer creates a workspace, the policy arrives with it.

    platform-team / backend-goTemplate
    AGENTSKimchi agent, 1 more agent CLI
    TOOLSGo 1.24, kubectl, terraform, golangci-lint
    COMPUTE4 vCPU / 8 GB RAM
    NETWORKAllowlist: github.com, proxy.internal:443
    SETUP SCRIPTruns on creation, e.g. make bootstrap
    $ kimchictl template list # templates are API objects too
    01

    Build the template once

    Agents, tools, compute, network policy, an optional setup script - defined once by an admin.

    02

    Developers create workspaces from it

    One click. The machine comes up with the right agents, tools, and policy applied. No setup tax, no drift.

    03

    Change the template, not 200 laptops

    A restart rebuilds the workspace with current tool versions. The fleet updates by editing one object.

    Security

    The agent uses your credentials. It never sees them.

    Store a token once in the Kimchi console. When a request leaving the workspace matches its host pattern, the gateway attaches the credential and forwards it on. The token never enters the workspace, never lands on its disk, and cannot be read back from the console.

    Workspace
    POST api.github.com
    ->agent calls a repo API
    boundary: credential injected here
    Kimchi gateway
    POST api.github.comAuthorization attachedmatching host pattern
    response returns - token stripped
    External service
    200 api.github.comauthorized, served

    No secrets in dotfiles

    Credentials live in the Kimchi console, not in files the agent can read. Values cannot be read back.

    Host-pattern matching

    A credential only reaches the service it belongs to. Any agent, any CLI, same enforcement - the policy lives in the gateway, not the agent.

    OAuth apps for the whole org

    An admin registers the app once; every member connects with their own account. Time-limited tokens, refreshed automatically.

    Developer experience

    One workspace. The agents your team already uses.

    Kimchi is bundled in every workspace, with your API key provisioned at creation. Templates can pre-install other agent CLIs alongside it - your developers keep the tools they chose, one governed runtime.

    workspace-7f2a / terminal 1
    $ kimchiready - key provisioned at creation$ kimchi "refactor auth middleware"planning edits across 6 files...workspace: 4 vCPU / 8 GB / allowlist active
    Kimchi - bundled in every workspace
    workspace-7f2a / terminal 2
    $ agent-two --versionpre-installed via template$ agent-two "write tests for auth"running on the same governed machineegress: github.com, proxy.internal:443
    Agent CLI 2 - pre-installed via template
    workspace-7f2a / terminal 3
    $ agent-three --versionpre-installed via template$ agent-three "review PR 482"same disk, same network policysecrets: gateway-injected only
    Agent CLI 3 - your team's pick, governed
    Access

    Work from the browser, your IDE, or an SSH prompt.

    Every workspace ships with a web IDE: file tree, terminals, Git, and the Kimchi extension pre-installed. One click opens it in your local editor; the SSH string drops the same workspace into any agent desktop app. Close the laptop: the session keeps running, and reconnecting restores it where it left off.

    Web IDE

    Any browser. File tree, terminals, Git, the Kimchi extension installed. Nothing to set up before the first prompt.

    Local IDE

    One click opens the workspace in VS Code. SSH config handled for you, once.

    SSH

    Copy the connection string into any terminal, or your agent's desktop app. The session runs in the workspace; your local tools and MCPs stay connected.

    18:47Laptop closes. Agent mid-task.
    ->
    02:14Workspace keeps running. Tests execute.
    ->
    09:03Reconnect. Same session, output intact.

    Idle workspaces hibernate after 24 hours and keep their disk. A restart rebuilds from the template with current tool versions.

    Governance

    Every change, on the record.

    The audit log records who created, changed, resumed, or deleted a workspace or template - old and new values side by side. Quotas cap how many workspaces can exist; refused creations get logged too.

    Audit logAutomatic
    Oct 09
    09:14    workspace.createdd.emian@acme.com created ws-7f2a from template backend-go
    Oct 09
    08:52    template.updatedk.nakamura@acme.com changed network policyallow-all -> allowlist: github.com, proxy.internal
    Oct 08
    17:31    quota.deniedwarningm.silva@acme.com hit the per-user workspace limit - creation refused
    Oct 08
    11:07    workspace.deletedd.emian@acme.com deleted ws-31b4

    Workspace and template events

    Every create, update, resume, delete - actor, timestamp, and the exact change.

    Quotas with teeth

    Org and user limits cap how many workspaces exist. Runaway creation is refused at the API, not discovered on the invoice.

    Tool-call observability coming

    What agents did inside a workspace, and what each session cost - on the roadmap, labeled honestly.

    Model routing and budgets, platform-wide

    Workspaces run inside the Kimchi platform: one gateway for agents, models, and spend.

    Run agents where you can govern them.

    Enable Workspaces for your organization, build your first template, and give your team's agents a place to run that security can sign off on.

    Book a demoRead the docs