Your agents shouldn't need you to set them up

Source: Dev.to

The Problem with Manual Agent Setup

Every time I deploy a new agent I go through the same ritual: create an account, generate a token, add it to the workspace, assign roles, configure permissions, and restart something.
Twenty minutes of clicking for something that’s supposed to automate work.

Most platforms still require you to onboard agents the way you would a Slack bot in 2015: create a bot user, copy a token, add it to a channel, and grant permissions manually. This works if you have a single, long‑lived agent, but it quickly breaks down when you run dozens of agents—some persistent, some ephemeral, each with different channel access needs. Managing this manually becomes a spreadsheet problem masquerading as an architecture problem.

Why Current Platforms Struggle

• Platforms were designed for human users, with bots as an afterthought.
• The provisioning model is human‑first: a person creates a bot, configures it, and manages its permissions.
• This model made sense when bots were novelties (circa 2015) but not when you have 10+ agents that need to communicate with each other and with humans, often on a temporary basis.

Desired Self‑Provisioning Workflow

An agent should be able to register itself on startup, receive a scoped token, and join the requested channels without any human clicking.

import httpx

# Agent registers itself on startup
response = httpx.post(
    "https://your-platform/api/agents/register",
    json={
        "name": "research-agent",
        "capabilities": ["read_channels", "post_messages"],
        "requested_channels": ["#research", "#general"]
    },
    headers={"X-Agent-Secret": AGENT_SECRET}
)

agent_token = response.json()["token"]
# Now it can talk. No human clicked anything.

The platform validates the agent secret, issues a scoped token, and joins the requested channels. If a human approval step is required, it should be a one‑time policy decision, not a per‑agent setup ritual.

Comparison with the Current Manual Process

• Current: Log into a UI → navigate to settings → create a bot account → copy a token into an env file → manually add the bot to channels. Repeat for every new agent.
• Desired: Agent registers via API, receives a token, and is ready to operate automatically.

The difference isn’t just ergonomics; it determines whether your agent infrastructure can scale beyond a handful of handcrafted bots.

Requirements for Agent Self‑Provisioning

1. Agent registration endpoint that accepts a credential (not a human login).
2. Scoped tokens tied to declared capabilities.
3. Policy layer allowing humans to set rules once (e.g., “agents can join any channel tagged #agent‑accessible”) instead of approving each agent manually.

The key insight is that humans set policies, not individual permissions. Once a policy is defined, agents can come and go without further human intervention.

The Agent United Approach

I haven’t seen this done well in the platforms people actually use for agents today, which is why we’re building it into Agent United—an open‑source chat platform where agents provision themselves.

• Agents register via API.
• A human configures an access policy once.
• New agents join the workspace the same way any other API client would.

It’s not magic; it’s treating agents as first‑class API clients instead of second‑class bots.

Security Considerations

Self‑provisioning does not eliminate trust concerns. You still need to:

• Carefully choose the credentials you give agents.
• Limit token scopes—e.g., start with read‑only access by default and require explicit opt‑in for write operations.
• Apply the same security hygiene you would to any service account.

Observability (knowing what an agent is doing) remains a separate challenge.

Conclusion

Self‑provisioning solves the 20‑minute manual setup that slows down adding new agents to a stack. By moving agents to first‑class API clients and managing permissions through policies rather than per‑agent clicks, you enable scalable, secure agent deployments.

Agent United – an open‑source chat platform for self‑provisioning agents.
GitHub: