L'Atelier: From a Tool I Ran Alone to One Teams Install
Identities for people and agents, a pull-request review that runs in a sandbox, and a lot of deleted code. What it took to run L'Atelier at Frak and at Circles.
On 2026-11-05 I had agents audit my own project: six read-only code lanes and three research lanes, while Frak, our company agent, checked their findings against the live cluster. The verdict was that most of it was built for adopters who do not exist. The repo carried two runtime backends, three SSH strategies, three image builders, a mock mode spread over 40 branches and a plugin framework for a single vendor.
Today, 2026-11-20, L’Atelier runs at two companies. At Frak, agents behind a chat gateway boot sandboxes in it, and the wallet repo’s CI uses it to review pull requests. At Circles, a company I work with, agents run under their own account, and the same review action runs on their wallet repo. Earlier posts cover why I built it, dispatching from Slack, the Kubernetes move, prebuilds and the Kata runtime. This one is about what changed when the second and third user were not me.
I set it up wherever I work for one reason. Atelier gives a coding agent a real machine, with the repository, its toolchain and a running dev server. Plug that into LibreChat, and through it into Linear, Plane or Notion, and a chat agent can do a developer’s work. Product people bootstrap a prototype themselves. A CEO queries the code. Developers start a long task before they leave in the evening and find a solid base waiting the next morning, or they dispatch several jobs at once: an exploration that would take forever by hand, a benchmark between two tools, a cleanup of the backlog.
Getting there meant deleting more than I added. The 11-05 merge alone removed 38,931 lines and added 26,552, across 570 files.
Who a Sandbox Belongs To
The cluster review found a trap that only appears with a second person. My org on Frak’s instance, frak, was my personal org, and it acted as the team org. When a teammate spawned a sandbox without choosing an org, it landed in their own personal org: no shared secrets, no auto-injected toolboxes, and nobody else could see it. The spawn worked and the result was quietly wrong.
The fix is one config key. auth.defaultOrg names the team org (commit ea7f7f84). Anyone who passes the GitHub gate joins it as member on first login, it is the default org for every spawn, and its owners are the server admins. Roles shrank to owner and member; admin and viewer are gone, and viewer had never been enforced anywhere. Production refuses to start without the key.
One Access Rule
Before that, sandbox access had been decided route by route. Aram’s Steery PR (#21, aramalipoor on GitHub, merged 2026-10-12) had one useful piece of it: an SSH key may enter a sandbox only if its owner created it or belongs to its org. Commit 3a5b67c0, in my rework PR (#22), made that the single rule for every way a sandbox id can be addressed: the HTTP routes, agent and terminal routes, both WebSocket upgrades, the MCP tools and SSH.
// apps/server/src/control/sandbox-access.ts (trimmed)
export function canAccessSandbox(deps, userId, labels): boolean {
const ownerId = sandboxOwnerId(labels);
// Before the bypass: a service account never reaches a person's sandbox,
// local mode included.
if (deps.isServiceAccount(userId)) return ownerId === userId;
if (deps.isAuthBypassed()) return true;
if (ownerId === userId) return true;
if (isOwnerOrOrgMember(deps, userId, labels)) return true;
return (
ownerId !== undefined &&
deps.isServiceAccount(ownerId) &&
deps.isServerAdmin(userId)
);
}
A denial answers 404, so a sandbox you cannot reach looks like one that does not exist. One guard per router is bound over this pure function in api/sandbox-guard.ts, so the next route inherits the rule.
Agents Get Their Own Account
The next problem showed up in my own setup. The chat gateway called Atelier with a person’s API key, so every agent acted as that person. Per the commit message of eca96762: its sandboxes were theirs, boot wrote their GitHub OAuth token (repo scope, no expiry) into every sandbox the agent drove, its commits carried their name, and when that person was a server admin the key reached /mcp/admin and every admin route.
A service account is a user of kind service. It has no console login, only API keys that an admin creates, and the key defaults to the mcp scope, which opens /mcp and nothing else. It owns the sandboxes it creates and reaches only those. It never receives a person’s GitHub token: it pushes with a GitHub App installation token that lasts an hour, narrowed to the permissions and repositories you list, committed as the App’s bot. Accounts can be declared in the server config, and their secrets come from environment variables:
// docs/service-accounts.md (excerpt)
{
"serviceAccounts": [
{
"name": "coding-agent",
"org": "agents",
"github": {
"appId": "123456",
"installationId": "7890123",
"privateKeyEnv": "CODING_AGENT_GITHUB_APP_KEY",
"repositories": ["my-repo"],
"permissions": { "contents": "write", "pull_requests": "write" }
},
"apiKey": { "env": "CODING_AGENT_API_KEY", "scope": "mcp" }
}
]
}
The docs carry a warning in bold that I keep rereading: the account gets every secret of its org, by name. An agent that can name a secret gets its value, so an agent belongs in its own org that holds only what it needs. Service-account sandboxes, snapshots and prebuilds are also untrusted by design: you take an agent’s work through a branch and a pull request, and forking its sandbox runs the copy with your token. Those are listed as known gaps. The threat model behind these choices is in the security post.
Both deployments run this. Frak’s infra repo generates the frak-agents account’s API key and stores it next to the App’s private key (4a7b8de); the same key is the gateway’s upstream bearer, which retired the old shared token. Circles’ infra declares two accounts: one for agents, and a second, read-only one for the review jobs, whose token is narrowed to read on contents and pull requests (41f27fa, ed5b0c2). The job posts the review and the sandbox cannot push.
A Review Action Other Repos Call
Once agents had identities, the obvious consumer was the pull request. I exposed a composite GitHub Action from Atelier’s own repo, actions/agent-review (c55b2336, 2026-11-17), with its Atelier MCP client, GitHub client and sandbox helpers in actions/shared (b926ca16), imported by relative path. A workflow that uses an action gets the whole repository and never an install, so the action runs on Bun with no dependencies and no build step.
# actions/agent-review/README.md (trimmed: workflow name, top-level permissions and most comments removed)
on:
pull_request:
types: [opened, reopened, ready_for_review, synchronize, closed]
concurrency:
group: agent-review-${{ github.event.pull_request.number }}
cancel-in-progress: true
jobs:
review:
if: github.event.action == 'closed' || !github.event.pull_request.draft
runs-on: ubuntu-latest
timeout-minutes: 60
permissions:
contents: read
pull-requests: write
steps:
- uses: frak-id/atelier/actions/agent-review@main
with:
atelier-url: https://atelier.example.com
api-key: ${{ secrets.ATELIER_REVIEWER_API_KEY }}
# Cancelled mid-review: the step above could not destroy its sandbox.
- if: cancelled()
uses: frak-id/atelier/actions/agent-review@main
with:
atelier-url: https://atelier.example.com
api-key: ${{ secrets.ATELIER_REVIEWER_API_KEY }}
mode: cleanup-head
The second step exists because a cancelled job cannot run the cleanup of the step it interrupted. A newer push cancels the review in progress, so the cleanup is gated on cancelled(). The README says to pin a tag or a SHA instead of @main, and the Frak wallet repo pins a SHA.
What a Review Remembers
Each finding gets an id (F1, F2) that stays the same across pushes. A review hides its state in its own body, as a gzipped base64 HTML comment: the findings still open, the ones dismissed, the head it saw. The next review is handed that state, the replies on each finding’s thread and the diff since that head, and it rules on every earlier finding as fixed, still open or dismissed before it looks at what changed (src/memory.ts). Only reviews posted by the job’s own account are read back, so a comment cannot plant state.
Later reviews report only new critical and major issues. A fresh round of small remarks on every push never ends, and I would rather have a review that goes quiet. Improvements follow a separate rule: a later review looks for them only in what changed since the previous one, at most 3 per category per 600 changed lines. Dismissal is a reply on the thread, and only the PR’s author, the repository’s owners, its org members and collaborators count. On a public repository a stranger’s comment could otherwise talk the agent out of a finding.
Pull requests from forks are skipped with a notice, and so are Dependabot’s: neither gets the secrets, Atelier cannot boot a fork’s branch, and the fork’s code would run with the org’s secrets. With subagents: auto, a diff of at most 500 changed lines (lockfiles aside) is reviewed by each agent alone, because sub-agents start cold and cost more than they find on a small diff (SINGLE_AGENT_MAX_LINES in src/prompt.ts). On a bigger one they are suggested and the agent decides.
Two Agents, One at a Time
The review runs two agents: one for issues (correctness, security, data, deploy impact, tests) and one for improvements (performance, duplication, conventions). I first wrote them to run at the same time (3ed9ec33, 11-19). A spike on Atelier staging showed that two pi processes started together under pi-acp 0.0.33 took each other down in 3 of 4 tries, so I staggered the second start by 30 seconds (4b8c2bc9). That guess lasted 36 minutes. The next commit (7508ca7f) found the cause: pi-acp keeps one live session, and a new session closes every other one, killing its pi process. Two raw pi processes do not interfere.
So the agents run one after the other. The issues agent gets up to 70% of the 40-minute default budget, the improvements agent gets what is left, and under 3 minutes it does not run. It is also told what the issues agent already reported. One side benefit stayed: the review of issues is posted as soon as its agent finishes, and the improvements are added to the same review later.
What the Wallet Repos Say
The review started as a script in Circles’ wallet repo, added on 2026-11-12. Within that day the agent had reviewed its own script five times (commit 7cb806728: “address the agent review’s fifth pass on itself”). On 11-17 I extracted that script into the Atelier action, and Circles moved onto it the next day (146074cc8), with the improvements agent a day after that (f49b26a8b).
At Frak, the wallet repo already had a pi-based PR reviewer. PR #469 (merged 11-18) added the Atelier action next to it, and PR #487 (merged 11-19) removed the old one. The body of #487 is the only side-by-side comparison I have, and its figures are mine, written into a PR description. On seven small PRs (lockfile bumps, build config) both said LGTM. On #480, pi said “No issues found” and Atelier raised one major and four minors; the major was that a new join label broke three Maestro flows. On #486, pi raised one minor and Atelier raised that one plus four more, checked against the code. According to #487, Atelier never missed anything pi found. It costs more: 2 to 6 minutes per review against pi’s 0.5 to 2.5, plus the runner and a sandbox.
Nine PRs and my own reading of them is thin, so I ran the action’s src/stats.ts on both wallet repos on 2026-11-20. It reads the state each review hides and sorts every finding on merged PRs into fixed (the agent’s ruling, at the review after the fix), dismissed (by a person, or by a later review that found it wrong) and still open at merge.
| Wallet repo | Merged PRs reviewed | Reviews per PR | Findings | Fixed | Dismissed | Open at merge |
|---|---|---|---|---|---|---|
| Frak | 18 | 1.5 | 21 | 14 (67%) | 1 | 6 |
| Circles | 25 | 2.7 | 279 | 174 (62%) | 18 | 87 |
The two teams use it differently. At Frak, 12 of the 18 reviewed PRs got no finding at all, which fits a stream of small changes. Circles’ PRs go through almost three rounds each. Of their 34 major issues, 30 were fixed before merge, and 81 of the 87 findings left open there are minor. Neither repo had a critical. The table counts outcomes; it cannot say how many findings were wrong in the first place, beyond the 18 dismissed.
The review sandbox runs the PR’s code, so the account behind it should be read-only and scoped to the one repository. The action’s README prescribes exactly that setup.
Deleting What Nobody Used
On 2026-09-24 I built the Launchpad, a light-themed surface for non-developers: a grid of curated starters, one click to launch, plain-English status, tools embedded in the page. The core of it landed in four commits within 24 minutes (spec, control module, routes, console), with a review-fix pass later that day. On 11-04 commit e163bfa3 removed it end to end. The message is three words long: “Nobody used it.” The diff was 87 files, 1,403 insertions and 7,145 deletions, plus a migration (0029_drop_launchpad) that drops its two tables.
It had no users because it was the wrong entry point. The Launchpad assumed that a non-technical person would come to Atelier, pick a starter and watch a sandbox boot. I now think they should never address Atelier directly. They should talk to an interface they already use, LibreChat, a Slack bot or a Linear agent, and that interface drives Atelier over MCP. Frak Studio, the video assistant at Frak, works that way. It takes a marketer’s request in plain language, boots that person’s workspace from a prebuild, starts the preview, briefs the coding agent, and opens a pull request for a developer to merge (docs/agents/frak-studio.md in Frak’s infra repo). The marketer never sees Atelier. The Launchpad was a second UI over what the MCP already served, built for people who had a better door.
The Launchpad was one of several removals in the simplify-2026-11 branch, merged on 11-05.
| Removed | Commit | Deleted | Added |
|---|---|---|---|
| Launchpad | e163bfa3 (11-04) | 7,145 | 1,403 |
| Host CLI, local mode kept via docker compose | d993d2a2 | 6,424 | 53 |
| Steery adapter and approval prompts | 47d2b9c2 | 8,449 | 368 |
| Mock mode, sshpiper, Dockerfile builds, daemonless BuildKit | 26995054 | 2,296 | 708 |
Steery let you answer an agent’s permission prompts from a phone. Aram wrote it, and the notifier went on 11-05 with a decision I took that day: agents approve their own permission requests inside the VM, and the VM is the boundary. That needed the network isolation and agent bearer token from c6b9ed84 first. Two pieces of his PR stayed and matter here: the SSH rule that became the access rule, and the metadata filter on sandbox lists, which the review action uses to find and destroy the leftovers of a dead job (destroyAll in actions/shared/src/sandbox.ts).
The image builder is the other. Kaniko is archived upstream, so on 09-23 I made daemonless BuildKit the default in-cluster builder (7f8caa06). Kaniko itself was removed on 10-13 (9954af26). On 11-05 the daemonless builder went too, since the cluster that matters runs BuildKit through an endpoint. The replacement I wrote lived 43 days.
Designing Tools for a Reader That Is a Model
The MCP surface went through the same pressure. On 2026-10-08 I trimmed every tool’s inputs and outputs for a model reader (1fd78e04): compact JSON, bounded output, nothing internal. create_sandbox returns an id and URLs, and the generated agent password, pod IP and SSH host keys are gone. Command output and process logs return bounded tails with an explicit timeout. Task tools default to a summary view, and a reply appears only once the turn has ended.
The next day I cut the tool count from 19 to 14 (5561d912). The old list had list_sandboxes next to get_sandbox, list_tasks next to get_task, dispatch_task next to send_prompt, and reply_permission next to manage_task. Every tool is a choice the agent has to make and a schema it pays for in each session, so siblings merged: get_sandbox lists when you omit the id, send_prompt starts a task with a sandboxId or continues one with a taskId. One rule came out of it that I would reuse anywhere. A parameter that only applies in one mode of a merged tool is rejected with an error naming it, never ignored. The case that mattered was autoApprove on a follow-up prompt: a caller who believes it is on would wait forever on a permission prompt.
On 11-05 the surface was split. Sandbox work stays on /mcp with 13 tools. Prebuilds, toolboxes, images and server config moved to /mcp/admin, 4 tools that only server admins can call. A test pins both lists by name:
// apps/server/src/api/mcp/tools/surface.test.ts
test("the sandbox MCP is exactly these 13 tools, in this order", async () => {
// ...
expect(await mcp.toolNames()).toEqual([
"whoami", "get_sandbox", "create_sandbox", "sandbox_lifecycle",
"destroy_sandbox", "exec", "read_files", "write_files",
"manage_process", "expose_port", "send_prompt", "get_task",
"manage_task",
]);
});
Adding a tool means editing that file on purpose. The same commit (905c5d00) made long operations asynchronous. Before it, create_sandbox, resume and prebuild creation blocked for minutes; a client timeout left an orphan sandbox, and the retry made a second one. Now create_sandbox returns {id, status, jobId} at once, with the name as an idempotency key, and get_sandbox takes waitSeconds to long-poll the outcome. Underneath, the HTTP routes and the MCP tools call one application layer (api/app/sandbox-ops.ts, toolbox-ops.ts). They used to have a copy each, and the copies drifted. MCP resume did not refresh git credentials, and MCP lifecycle operations never showed in the console’s job feed.
Slow tools also cross other people’s proxies. The MCP gateway in front of Atelier at Frak capped backend calls at 10 s, and send_prompt and get_task failed at exactly 10.0 s on 2026-10-13; the infra repo now gives Atelier calls 290 s (eecdbff).
The first generation of this surface, with workspaces and session templates, is in the Slack MCP post. None of those tools survives.
Not Burning a Node
Both instances run on Hetzner hardware, Frak’s on a single bare-metal node, and every sandbox holds a Kata VM (2 vCPU and 4 GiB by default) until someone pauses it. Night is when that hurts. A lot of work gets dispatched before people leave, each task finishes at some point in the night, and its sandbox keeps its memory until morning, next to the ones somebody simply forgot.
Commit a69a41bc (10-13) pauses idle sandboxes, with a rollout I would repeat: the mode defaults to observe, which computes and shows when a sandbox would pause and never pauses one, until the operator switches to enforce. The default idle time is 120 minutes. Frak and Circles both have idle pause switched on now. A paused sandbox gives its memory back to the box, and its owner resumes it whenever they come back to it.
Activity is measured in bytes and file writes, and an open connection alone does not count. A forgotten code-server tab exchanging heartbeats does not keep a sandbox awake; an agent streaming from an LLM API does. A turn in flight blocks the pause. A paused sandbox wakes when someone opens its URL, uses SSH, or sends a prompt.
Pausing created a second problem. A task with no activity for an hour used to be deleted, so the next send_prompt got a not-found and the new task started with no context, even though the agent’s session was still on disk. Commit 9f374a4b (10-16) parks the task instead: it releases its hold on the shared ACP connection so the sandbox can pause, and keeps the session id. The next prompt reopens the same agent session through ACP session/load, asking to resume the sandbox first if it is paused. Parked tasks are forgotten after a week.
Installing It Somewhere Else
There is no installer. The old Helm chart was removed on 2026-09-29, and an installer is the first item under “Next” in docs/roadmap.md. A new org today follows docs/setup.md: apply the manifests in infra/k8s/ in order, with the cluster prerequisites already in place. Atelier deploys only its server and console. It consumes kata-deploy’s RuntimeClass, TopoLVM, Zot, BuildKit, cert-manager and Traefik by name; at Frak those belong to the infra repo. The server refuses to start on an unknown config key. It also refuses without SANDBOX_SECRETS_KEY and, in production, without auth.defaultOrg. For a single user there is a local mode, docker compose -f docker-compose.local.yml up, with sandboxes as Docker containers and no isolation worth the name.
Releases come in two kinds. Every push to main publishes a rolling nightly image and a nightly-<sha> one, and a v* tag publishes semver images. The latest tag, v3.0.2, is from 2026-11-11 and predates both service accounts and the review action, so both companies run nightlies. One upgrade rule surprises people: the in-pod agent reaches a sandbox only through its base image, so after a deploy you rebuild dev-base and refresh the prebuilds (docs/setup.md, “Upgrading to this release”).
What Is Still Rough
Prebuilds are not scoped to an org and everyone boots the newest bake of a repo, so a service account’s bake can run agent-chosen code with a person’s token. The docs list it as a known gap and recommend taking an agent’s work only through git.
I have not measured what a review costs in model spend, and the only review times I have are the ones in #487, from nine PRs.
I wrote the core of the Launchpad in four commits in 24 minutes and deleted it 41 days later. Next time I will ask who will open a surface before I build it.
The pi-acp single-session limit is upstream, and my sequencing works around it. If pi-acp learns to keep sessions side by side, running the two agents in parallel would cut the review’s wall time, and the 70% rule goes away with it.