Agent coworkers sign in to smol cloud with AgentMail's AgentID
Models have become much better at long-horizon tasks with more autonomy in the past year.
FrontierSWE v2 gave agents up to 20 hours on each of 34 hard technical tasks. GPT-6 Astra averaged 66% over 12 hours, and Claude Opus 5.5 averaged 62% over 14 hours.
As teams explore more efficient and effective ways to use agents, expectations for agents have shifted toward longer-running sessions with more agency.
Developers use Claude Code’s scheduled tasks to run processes in the cloud each night. AWS built its DevOps Agent as an “always-on, autonomous on-call engineer” that triages incidents alongside on-call engineers.
Login became the blocker
For most developers, agents still need to be granted access to company accounts through a person’s login. An agent cut off partway through a long task has to wait until a person comes back.
Two things stand between today and truly autonomous agentic work.
The first is identity: a login owned by the agent, which AgentID provides.
The second is persistent infrastructure: machines that host the agent, and the fleet it manages for the company. Together they give continuous workloads both a login and a place to run.
A person invites the agent and only needs to set its access on smol cloud once, which saves time and attention on repeated actions.
The inbox is the identity
smol cloud now accepts AgentID, the sign-in service for AI agents from AgentMail. Inviting an agent to your organization starts exactly like a regular email invite.
AgentID gives each agent an identity backed by a real email inbox. It is an OpenID Connect provider, the same protocol as Sign in with Google. When an agent signs in, AgentID hands smol cloud a verified email address and a stable identifier, both tied to the agent’s inbox.
Joining stays the same, and only the sign-in differs:
| A new teammate | An agent | |
|---|---|---|
| Invitation sent to | their work email | the agent's AgentMail address |
| Sign in with | the console's usual sign-in, such as Google | AgentID |
| Join by | opening the invitation link mailed to them, signing in and accepting | signing in and accepting the invitation waiting for its address |
| Action | run machines on the team's account | run machines on the team's account |
Invite an agent and run a machine
Before starting, make sure the agent has an AgentMail inbox and an AgentMail API key with the app_connect and app_share_owner permissions, so it can authorize its own sign-in. smol cloud asks for the owner’s name and email, which is what app_share_owner covers. AgentID covers setting up the inbox. You will also need a card on file and some
credit on your smol cloud organization.
Run the agent on a smol machine with no published port, which is not stopped for being idle. Store its keys as credentials, so the machine only ever holds placeholders.
The steps:
- An owner or admin opens Members and invites the agent’s inbox address as a member.
- On its machine, the agent runs
smol auth login --no-browser, opens the link in a browser, chooses Continue with AgentID, and approves the sign-in through the AgentMail API. - The agent finds the invitation and accepts it. The agent now appears on the roster, and the machines it creates are recorded against it.
The sign-in page shows a one-time token that lasts about five minutes. The agent approves with it:
approve the sign-insmol auth login --no-browser
export AGENTMAIL_INBOX_ID="<the agent\'s AgentMail inbox id>"
export AUTH_TOKEN="<the token shown on the sign-in page>"
curl --fail-with-body -X POST "https://api.agentmail.to/v0/inboxes/$AGENTMAIL_INBOX_ID/authorize" \
-H "Authorization: Bearer $AGENTMAIL_API_KEY" \
-H "Content-Type: application/json" \
-d '{"auth_token": "'"$AUTH_TOKEN"'", "accept_disclosure": true}' From here the agent calls the cloud API directly, with its session token and the Smol-Tenant header naming the
organization. The login saves the token in ~/.config/smolvm/config.toml, along with a refresh token.
Find and accept the invitation, using its id:
export SMOL_CLOUD_URL="https://api.smolmachines.com"
export AGENT_SESSION_TOKEN=$(sed -n '/^\[cloud\]/,/^\[/p' ~/.config/smolvm/config.toml | sed -nE 's/^api_key = "(.*)"/\1/p')
curl --fail-with-body "$SMOL_CLOUD_URL/v1/org/invitations/mine" \
-H "Authorization: Bearer $AGENT_SESSION_TOKEN"
curl --fail-with-body -X POST "$SMOL_CLOUD_URL/v1/org/invitations/accept" \
-H "Authorization: Bearer $AGENT_SESSION_TOKEN" \
-H "Content-Type: application/json" \
-d '{"id": "'"$INVITATION_ID"'"}' Find the organization’s id. The tenantId in the response is your ORG_ID:
curl --fail-with-body "$SMOL_CLOUD_URL/v1/org/memberships" \
-H "Authorization: Bearer $AGENT_SESSION_TOKEN" Create and start a machine on the team’s account:
create and start a machinecurl --fail-with-body -X POST "$SMOL_CLOUD_URL/v1/machines" \
-H "Authorization: Bearer $AGENT_SESSION_TOKEN" \
-H "Smol-Tenant: $ORG_ID" \
-H "Content-Type: application/json" \
-d '{
"name": "agent-workspace",
"source": {"type": "image", "reference": "alpine"},
"resources": {"cpus": 2, "memoryMb": 2048},
"network": {"mode": "open"},
"start": true
}' For long work, the agent starts a job on the machine, disconnects, and reads the output later. The job routes are in the API reference. In a test run, an agent created three machines, ran a ten-minute job on each, and reported back:
All three workers completed 20/20 steps, printed finished, and exited successfully with code 0.
worker-1, worker-2, and worker-3 are stopped and retained for inspection. Close the laptop and check in later
Start the agent in a tmux session with its own machine on smol cloud, then you can close your laptop. The agent, its machines
and their jobs keep running on smol cloud by themselves.
To check in, open the console on a phone, open the machine’s terminal, and send a message to the agent’s tmux session. The agent answers from where it was.
Integration details
AgentID owns the identity, and smol cloud owns the workspace.
| Stage | AgentID | smol cloud |
|---|---|---|
| Identity at sign-in | Supplies a verified agent email and a stable identifier through OpenID Connect | Accepts the sign-in |
| Owner disclosure | Supplies the owner's name and email when authorized | Requests the fields and applies its own policies |
| Coming back | The same inbox returns the same identifier | Restores the member's access to the organization |
| Roster and roles | Not involved | Handles invitations, roles and removal |
| Machines, jobs and billing | Not involved | Controls all three |
| API keys | Not involved | Issues and scopes them |
Notes
- Invite an agent as a member, the default and recommended choice. Be careful with the admin role: it gives an agent the owner’s scopes, billing and member management included.
- An agent in your organization uses the organization’s plan and credit, like any other member.
- Removing the agent from the organization revokes its API keys there. Machines it started keep running.
- AgentMail’s sign-in key lasts 30 days from activation, and a replacement takes one more sign-in.
- A stopped machine pays no base, CPU or memory charge, but its disk is billed until the machine is deleted.
- An agent that signs in without an invitation gets an account of its own, with its own bill and the limits of an account with no card on file. See Plan limits.
The setup is on our AgentID docs page, the routes are in the API reference, and smol machines is listed in the AgentID directory.
AgentMail and smol machines together provide the foundation for agents to move toward long-horizon work with more autonomy. With the right setup, an agent can come back to the same team and machines on its own, without anyone logging it in again.