Blog

Introducing kosem. Coding agents with native environments, identity and access

Coding agents are reliving the mainframe and minicomputer era. Anyone who was there, or read about it in a history class, knows the setup: people reached a central computer through terminals to get their work done. One big job slowed everyone down, and even once each person had a user of their own, everyone still shared one operating system.

Now the developer's laptop is the mainframe, and the agents are the people at its terminals, all sharing one operating system and the developer's identity and access, while the developer supervises them through a terminal emulator.

Today we're introducing kosem: coding agents with native environments, identity and access. Each agent gets an environment of its own, an identity of its own, and only the access you grant it, instead of the developer's laptop and keys. kosem is in private beta, and we're opening it to more teams as we roll it out. Join the waitlist, and read on for what's inside and how we built it.

Go idle0:47 / 0:47
One task in kosem, from the first message to the pull request.

Why today's coding agents break

Today's coding agents run on the developer's laptop, as the developer, and that breaks in two ways. The biggest is security. Then come performance and productivity.

Security

An agent needs what a developer needs to get work done: private code and secrets, text from strangers in issues, docs and dependencies, and a way to push and call out. That's Simon Willison's lethal trifecta,[1] and it can't be designed away, since the work needs all three. Any text the agent reads can carry a prompt injection, so it needs defense in depth. On a laptop, only the first layer is there:

  • The model. System prompts and training teach it to follow the developer rather than what it reads, and models keep getting better at it. Anthropic says that isn't enough: prompt injection is "far from a solved problem."[2]
  • Least privilege. An injection that gets through should reach only what the task needs. On a laptop, the agent runs as the developer, so one injection reaches everything: their GitHub and cloud credentials, their SSH keys and every repo on their disk.
  • Audit. Afterwards, the team needs to see what the agent read and ran, what to roll back and what to rotate, and to trace each commit and cloud call back to it. On a laptop, every action is logged as the developer, and the transcript sits in their home directory, where the agent can rewrite it and Claude Code deletes it after 30 days by default.[3]

The patches on top mostly add friction. Approval prompts aren't a security boundary,[4] and Anthropic says they lead to "approval fatigue."[5] OS sandboxes share the laptop's kernel, the docs say not to rely on them "to stop a malicious command,"[6] and they break tools like docker.[7] So everyone ends up running --dangerously-skip-permissions, which is a little unfair to the flag: without it, the agent was almost as dangerous.

Performance and productivity

The second set of problems is the mainframe's. Every agent on a laptop shares one machine, and each agent a developer adds makes it worse:

  • They step on each other's toes. Agents on one laptop share its ports, its Docker daemon, its databases and often its working tree. One switches branches under another, one's tests take the port another's dev server needs, and one's migration resets the database another is testing against. Git worktrees separate the files, not the rest.
  • They compete for the same cores. One agent's ten-minute build takes every core, and the other agents, and the developer's own editor, wait on it. A laptop can't grow for the build and shrink back while the agent reads code.
  • They stop when the laptop does. A task that runs for hours needs a machine that stays up for hours. Close the lid, or lose the Wi-Fi on a train, and the agent stops mid-task, so the developer keeps the laptop open and babysits a row of terminal tabs.
  • Their work is one developer's alone. The transcript, the branch and the half-done work live on one laptop. A teammate can't see how a fix was verified, steer an agent while its developer is out, or pick up the task where it stopped.

Both sets of problems have one cause: the agent borrows the developer's machine and identity. So the line belongs in two places. Around the machine: the agent gets an environment of its own, with its own kernel and nothing of the developer's in it, so it can run freely. And at its edge, where it reaches the outside world: its own identity, only the credentials its task needs, and a record of everything it did with them. Two developers don't share a laptop or a login, and two agents doing different tasks shouldn't either.

What kosem is and how it works

In kosem, each agent gets three things of its own: an environment, an identity with only the access its task needs, and models through one gateway. Around the agents, the team gets IAM for its people and an audit trail of everything. How we built environments, access and audit will each get a post of its own.

Your team

MMayaStarts and steers the agent
DDavidApproves what's on prompt
Sets the permission set, the size limit and the budget once
IAM for people
  • MMayaAgents Useron project checkout
  • DDavidSecret Accessoron secret aws/prod-logs
  • SSamAgent Vieweron agent ags_…r7tx
Roles on the organization, its projects and single resources, such as one secret. Agents hold none.
who can start, read and steer it

Agent

agent:ags_01m9…r7txDirected by Maya
Its own identityNo keys of its ownTranscript kept in kosem
calls models
LLM Gateway
Model
best
This agent
$3.18
Project
$412 of $2,000
Keys stay in kosem, never in the agent's environment
on your accounts

Model providers

Anthropic
OpenAI
Google Gemini
Your own server
runs its commands inasks for access
Environments A fleet of microVMs, one for each agent, each from its team's image
RunningStoppedRunningRunning
This agent's microVMLarge · 4 vCPUs · building Disk kept while idle Credential broker
Its own kernel, root and DockerResized within the team's limit
asks · issues
IAM for agents
The team's permission setgrantedgithub/acmepromptaws/prod-logs · David approvesdeniedEverything else
The task's leaseGitHub · acme/checkout · 60 minAWS · one log group · one commandMinted when a command asks the broker, narrowed to it. Ends with the task.
mints, narrowed

Integrations

GitHubApp installation token, scoped to reposAudit log · hashed_token
AWSAssumeRole with a session policyCloudTrail · accessKeyId
Google CloudShort-lived access tokenCloud Audit Logs
records every credential
Audit
  1. Maya started agent:ags_…r7tx
  2. agent:ags_…r7tx was issued github/acmehashed_token 3f9a…c1
  3. David approved aws/prod-logs · one command
  4. agent:ags_…r7tx was issued aws/prod-logsaccessKeyId ASIA…7Q2M
joined on the ID
kosem's building blocks, around one agent.

Environment

Each agent gets an environment of its own: a microVM with its own kernel, adjustable CPU and memory, a persistent disk, and any Docker image from your registry, so it starts with the team's languages, databases and tools. The agent is root and runs Docker inside it, and nothing of the developer's is there, so it doesn't have to ask before each command.

The agent picks its environment's CPU and memory and changes them as the workload does, within the team's limits: small to read code, large for the build. Each step gets what it needs and no more, so less goes to waste. When the agent goes idle, waiting on someone's answer, its environment stops but its disk persists, so it resumes where it left off in seconds. It keeps working with the laptop's lid closed, and agents no longer share one laptop.

Identity and access

Every agent is a principal of its own, agent:ags_…, and starts with no access at all. The team grants it secrets, and nobody can grant more than they hold: granting a secret to an agent takes access to it.

For GitHub, AWS and Google Cloud, kosem mints short-lived credentials when a command asks for them, narrowed to the request, so no long-lived key enters the environment. Static secrets are the exception, for services that can't mint short-lived tokens yet.

The team marks each secret granted, prompt or denied: the agent uses what's granted without asking, asks a teammate before it uses what's on prompt, and says when something is denied instead of working around it. When the task ends, its access ends with it.

Models

Agents call models through one gateway: every model the team turned on, on the team's own accounts at Anthropic, OpenAI and Google Gemini, or any compatible server. Provider keys never reach an agent or a person.

The organization decides which projects can use which models, and sets spend limits for itself and for each project. Usage is broken down by project, model and agent, so spend ties back to the work it paid for.

People and projects

People get permissions of their own, separate from the agents'. One organization holds your people and your projects, and you shape it the way your teams work: a project for each team or service, and groups for the people who work together.

Roles decide who can do what, at the level you choose: the whole organization, one project, or a single agent or secret, for a person or a whole group. They're granular, so you can split who views, starts and steers a project's agents, who can use which secrets, and who can grant them to agents. Billing, members, policies and the audit log have roles of their own, so nobody needs to be an admin of everything.

Agents are shared with their project by default, so a teammate can read a run, answer the agent's question or pick the task up where it stopped. An agent can be private too, shared only with the people you choose.

Audit

kosem keeps a record of everything, where the agent can't change it. The transcript, every message, command and result, lives in kosem, where the team can read it and the agent can't rewrite it. Every action is logged too: creating an agent, granting a secret, changing a role and reading a transcript.

Every credential is recorded under the agent's name, with GitHub's hashed_token or CloudTrail's accessKeyId, to join with the provider's own logs. In AWS, the agent's name is each session's source identity, so CloudTrail shows which agent made each call.

Get started with kosem agents

Register for the private beta on the waitlist, and we'll email you when your team's access is ready.

Your first agent starts with an environment of its own and nothing else. Give it a task and grant it what the task needs. Then follow its work from your laptop or your phone, and steer it together with your team.