← Blog
Partnerships

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 teammateAn agent
Invitation sent totheir work emailthe agent's AgentMail address
Sign in withthe console's usual sign-in, such as GoogleAgentID
Join byopening the invitation link mailed to them, signing in and acceptingsigning in and accepting the invitation waiting for its address
Actionrun machines on the team's accountrun 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:

  1. An owner or admin opens Members and invites the agent’s inbox address as a member.
  2. 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.
  3. 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:

smol 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:

curl --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.

StageAgentIDsmol cloud
Identity at sign-inSupplies a verified agent email and a stable identifier through OpenID ConnectAccepts the sign-in
Owner disclosureSupplies the owner's name and email when authorizedRequests the fields and applies its own policies
Coming backThe same inbox returns the same identifierRestores the member's access to the organization
Roster and rolesNot involvedHandles invitations, roles and removal
Machines, jobs and billingNot involvedControls all three
API keysNot involvedIssues and scopes them

Notes

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.

RSS feed