Onboarding a company
Who does what to get one developer's agent working under AgentBox, in an enterprise where the platform team holds the keys and developers hold none. Two roles, in order.
The shape: each developer runs the core Compose stack on their own machine. Their workspace container is the only place the agent runs. The broker beside it signs GitHub App requests with a key the developer cannot read (KMS) and identifies the workspace by a signed assertion issued through the platform team's identity provider. Nothing in the developer's checkout, home directory, or IDE holds a GitHub or model credential.
Platform team, once per organisation
GitHub App
Create it with Contents: read and write, Metadata: read, and, for agentgate pr and agentgate ci, Pull requests: read and write and Actions: read. Install it on the repositories agents may touch. Record the App ID and installation IDs. See Connect GitHub.
Signing key in a KMS
Put the App private key in AWS KMS (or your HSM) and grant each developer's role kms:Sign on it and nothing else. Developers' brokers sign with AGENTGATE_KMS_KEY_ID (built in) or AGENTGATE_SIGN_COMMAND; the PEM never exists on a laptop. See KMS signing.
Issuer key
Generate the Ed25519 issuer keypair on an issuing host the platform team controls. Only the public key goes into broker configuration; the private key goes to the issuing service.
Policy, entitlements, egress
Write config.json with identity.mode: "assertion", the issuer public key, the repositories, and rules that requires team membership or a ticket. Wire entitlements to your directory export, GitHub teams, Okta, Entra, Jira, or ServiceNow. Choose an egress allowlist (examples/egress.ide.json if developers attach an IDE). See Policy, Entitlements, Egress proxy.
Model gateway
Put the provider API key in the gateway's secret and set the budget. See Model gateway.
Images
Build and sign the broker image and the workspace profile your developers need (examples/workspace-claude-code.Dockerfile for Claude Code). Publish by digest. See Workspace profiles and Verify release images.
Approvals and the issuer
Stand up compose.enterprise.yaml behind your OIDC provider: approval-web so reviewers approve with a verified identity (set reviewerSources: ["oidc"] on rules that matter), and issuer-web so developers mint their own identities at /issuer/.
Audit
Point the audit forwarder at your SIEM and load the detections. See Audit & monitoring.
Bundle it
Give developers a repository containing compose.yaml, the pinned image digests, config.json, the egress allowlist, the gateway config, the CA for the workspace-to-broker hop, and a .env.example with everything but the per-developer values. Developers run the core compose.yaml only; the SIEM forwarder, approval UI, and issuer run wherever reviewers and the audit pipeline live, and their settings never need to be on a developer's machine.
Note
If reviewers must approve with a verified OIDC identity, the approval host needs the developer's broker state, so plan broker placement (developer machine versus shared host) with that in mind.
Developer, once per machine
About ten minutes with the platform team's bundle in hand. Windows works through Docker Desktop with WSL 2; run these commands in the WSL shell, which is also what the Dev Containers extension uses.
Clone the bundle
Bootstrap your machine's secrets
npm run bootstrapThis generates your workspace client token (it identifies your workspace to your broker and never leaves your machine), the model-gateway token, and a development CA, and writes their paths into .env. It ends by listing what is still missing: fill in the App ID and key (or KMS) settings and the model key file path from your platform team.
Set your commit identity
AGENTGATE_GIT_NAME and AGENTGATE_GIT_EMAIL in .env.
Bring the stack up and get your fingerprint
docker compose up -d --build
docker compose exec workspace agentgate fingerprintThis prints the SHA-256 of your client token. Paste the fingerprint, never the token, into the issuer with the agent you use, your team, the work mode you need, and the ticket you are working.
Install your runtime assertion
Save the assertion the issuer shows you, point .env at it, and renew:
cp ~/Downloads/runtime-assertion ~/.agentgate-runtime-assertion
echo "AGENTGATE_RUNTIME_ASSERTION_PATH=$HOME/.agentgate-runtime-assertion" >> .env
docker compose up -d workspace
docker compose exec workspace agentgate doctordoctor shows who you are acting as, when the assertion expires, that it is bound to your token, and that the broker, gateway, and proxy are reachable. Every check must be ok.
Open the workspace in your editor
Reopen in Container from VS Code, Cursor, or Windsurf (IDEs & workspace profiles), or use the terminal:
docker compose exec workspace bash
git clone https://github.com/YOUR-ORG/YOUR-REPOWork normally
Clone, fetch, push, agentgate pr create, agentgate ci list. A push that policy sends to approval fails with a request ID; a reviewer approves in approval-web; push again.
Without the issuing service
On the issuing host, with the developer's fingerprint and their entitlement details:
node scripts/issue-runtime.js --key issuer.pem --kid k1 --audience agentgate:acme \
--client-token-sha256 <fingerprint from the developer> \
--runtime-id rt-jane-laptop --human jane@example.com --agent cursor --team payments \
--mode build --task jira:PAY-12 --gh-login jane-example --ttl 28800 --out runtime-assertionReturn the runtime-assertion file to the developer. It only works with the token whose fingerprint it carries, on that developer's broker, but treat it as a secret anyway: it names a person and a task. Renewal is the same command with a new --ttl; the developer replaces the file and runs agentgate renew.
What the developer never has
- The GitHub App private key or any installation token (KMS signs; the broker holds tokens in memory only).
- The model provider key (the gateway injects it).
- The issuer private key (the developer cannot widen their own identity).
- A GitHub credential in the IDE's Git integration (the devcontainer disables it, and the egress proxy denies GitHub anyway).
What still needs the platform team's judgement
- The Compose stack runs on the developer's machine, so the developer is that machine's container administrator: they can read their own client token and admin socket. The security claim is that the agent cannot exceed the delegated identity, not that the developer cannot.
- The IDE's own assistant (Cursor's, Copilot's) sends prompts to its vendor from the developer's machine; only tools that honour
ANTHROPIC_BASE_URLgo through the gateway. - The issuing service authenticates the developer through the identity provider, but its Ed25519 key is a file on the issuer host. Turn on
identity.delegationso the broker re-checks the team claim at verification time too.