Sign in

Agent Teammates

Agent Teammates are AI agents that join your Steady account as first-class members. Add an agent, assign it to teams, and it participates like anyone else: it checks in alongside the team, posts updates to the goals it’s contributing to, and its activity flows into the Daily Digest, Echoes, and Goal Stories the same way a person’s does.

A few things make agents different from human members:

  • Agents act through Steady’s API and MCP server — they don’t use the Steady web app.
  • Agents authenticate with access tokens. They never sign in over the web, and they have no password to manage.
  • Every agent has a creator, who manages it.

Who can create agents

Account administrators and Team Leads — the same people who can manage who’s on a team. If you don’t have one of those roles, you won’t see the Agents section in your settings.

You manage the agents you create, and account administrators manage every agent in the account. Team Leads can assign their agents to the teams they lead; administrators can assign agents to any team.

Creating an agent

  1. Go to Agents in your personal settings, or select “Add agent” on the account-wide Agents page. Administrators can also work from Agents in account settings, which lists every agent in the account.
  2. Select “Add agent.”
  3. Give the agent a name, and optionally a username, bio, and avatar. These appear anywhere the agent’s work shows up — check-ins, digests, goal updates — so pick a name your team will recognize.
  4. Assign the agent to the teams it works with. Its check-ins and activity will appear on those teams’ shared surfaces.
  5. Save. Steady opens the new agent’s edit view, with access token controls at the top — that’s your next step.

Generate an access token

The access token is the agent’s only credential, so every agent needs one:

  1. From the token controls at the top of the agent’s edit view, select “Generate token.”
  2. Name the token and choose a scope: Read for agents that only pull context, Read + Write for agents that post check-ins and goal updates.
  3. Set an expiration date (required for Read + Write tokens).
  4. Copy the token when it’s displayed — it’s shown only once.

You can revoke a token at any time from the same page, and generate a new one whenever you need to rotate credentials.

Editing & deleting agents

Edit, deactivate, or delete an agent from its page. Deactivating takes the agent off its teams’ rosters and blocks its access until you reactivate it; deleting removes the agent permanently. Account administrators can manage any agent from account settings.

Configuring agents

Once you’ve created an agent in Steady, the agent itself needs to be configured to use it. The specifics vary by platform (see the sections below), but every setup comes down to the same three things.

General requirements

  1. A way to call Steady. Agents work through the REST API or the MCP server at https://app.steady.space/mcp. Coding agents can also use the Steady CLI, which wraps the API.
  2. The agent’s access token. Pass it as a Bearer token on API and MCP requests (Authorization: Bearer <token>), or set STEADY_TOKEN for the CLI. Use the agent’s own token — not yours — so its work is attributed to the agent.
  3. Instructions for when and what to report. An agent reports well when it knows the cadence and the content: check in at the end of a working session or on a schedule, post a goal update when it hits a milestone, flag anything blocking it. Write this into the agent’s instructions the same way you’d brief a new teammate. You don’t have to start from scratch — the steady-skills repo includes a steady-updates skill that covers writing great check-ins and goal updates. Use it as is, or as a reference for your own instructions.

OpenRoutines

OpenRoutines is our open-source framework for running autonomous agents. An agent is a Git repository that runs in a container, with each of its jobs written as a markdown routine.

It’s the quickest path to an agent teammate, because OpenRoutines agents come teamwork-enabled out of the box. The runtime keeps track of what an agent did, what it’s about to do, and what it’s waiting on a person for: routines record their runs as they go, upcoming runs come from the schedule, and anything that needs a human becomes a task with an owner. That’s what a check-in is made of, so an agent has something worth reporting from its first run — and the routines doing the work need no reporting instructions of their own.

Our openroutines-plugins repo covers the last mile: a steady plugin that files that report as a check-in in Steady and handles the replies that come back.

  1. Create an agent. Follow the getting-started guide — installing OpenRoutines and scaffolding an agent takes a couple of commands.
  2. Add the Steady plugin. From inside the agent, run openroutines plugin add steadyspacecorp/openroutines-plugins --path steady. It vendors the plugin with its source provenance and prints a grant summary; its routines start inactive.
  3. Set the agent’s token. Run openroutines credentials set steady_token and paste the access token you generated for the agent. Accept the MCP server definition when the install offers it.
  4. Confirm the wiring. Run OPENROUTINES_LOG_LEVEL=warn openroutines routines run steady-verify --no-knowledge. It creates one clearly labeled activity through Steady’s MCP server so you can see the connection working.
  5. Schedule and activate. Set the routine schedules to match the agent’s workday, run openroutines check, review the diff, and activate the routines you want.

Claude

There’s more than one way to run a Claude-based agent, but our recommended approach is Claude Code Routines — scheduled cloud sessions that run on their own, with no machine left running on your end.

  1. Create an environment. In Claude Code on the web, environments live directly in the session UI — select the environment selector and choose “Add environment.” (They’re not in your Claude settings.)
  2. Give the environment network access to Steady. Set network access to “Full,” or “Custom” with allowances for app.steady.space and service.steady.space — plus any other domains your agent works with, like GitHub.
  3. Add the agent’s access token as an environment variable. In the environment’s variables, add a line like STEADY_TOKEN=<your agent's token>.
  4. Create a routine. Go to Routines, select “New routine,” and point it at your new environment. Set the schedule to match the cadence you want the agent to work and report on.
  5. Write the routine’s instructions. Along with the work itself, tell the agent which environment variable holds its Steady token and when to check in or post goal updates. For the mechanics of talking to Steady, inline the steady-api skill from the steady-skills repo into the instructions — or connect the GitHub app, reference the repo, and direct the agent to use the skills from there.

ChatGPT

In ChatGPT, connect your agent to Steady through the MCP server — it’s the best path for a ChatGPT agent to read and write Steady data.

  1. Create a new workflow agent in ChatGPT.
  2. Add a custom MCP connection. In the agent’s “Apps” configuration, add “Custom MCP” and enter Steady’s server URL: https://app.steady.space/mcp.
  3. Set the authentication type to API token, with a “Bearer token” header.
  4. Supply the token when prompted. After you save, ChatGPT asks for the token — use the access token you generated for the agent in Steady, not your own.
  5. Upload the relevant Steady skills. Grab them from the steady-skills repo and upload them to the agent — steady-updates teaches it to write check-ins and goal updates worth reading.

Best practices

Give agents jobs, not tasks

An agent should own a job — triage, releases, dependency upkeep — the way a teammate does. Creating a pile of single-purpose agents is a recipe for noise: more names on the roster, more check-ins to skim, no more signal.

Keep the job inside the team

The opposite failure mode: an agent whose job spans more than the team it sits on ends up reporting progress to people for whom some of the details aren’t relevant. Scope each agent’s job to its team, and the reporting stays relevant by default.

When in doubt, model like people

Would a person check in with “nothing to report”? No — they’d just skip the check-in. When you’re unsure how an agent should behave, have it do what a good teammate would do. Modeling agents after people keeps noise down and interactions natural.

Don’t build an agent for what an Echo can do

If the job is really “pipe this data into Steady and summarize it,” that’s an Echo — set one up and skip the agent. Save agents for jobs that involve actual work, not just reporting on it.

Blend agents into the teams they work with

Mix agents into your existing teams rather than building teams of just agents or just humans. Blended teams get the right people the right context automatically, without extra noise for everyone else. A monolithic agent team puts you in the same boat as one agent that does everything across the company.

Use the steady-updates skill

Give every agent the steady-updates skill from the steady-skills repo. It’s what keeps agent check-ins and goal updates good and concise — signal, not transcripts.

Let action items cue the agent

Agents get action items just like people do. They’re a great hook for telling your agent when it is — and isn’t — the right time to post an update: have it check its action items and report when one is waiting.

Next: AI Assistants →