One agent.
Every system.

Your production stack lives in a dozen tabs.

An outage rarely stays in one system. You read logs in one console, query the database in another, SSH into a host, check the cluster, and piece the story together yourself at two in the morning. Agents are good at exactly this kind of cross-system detective work. The hard part has always been letting them in safely.

Why, Mr. Anderson? Why do you persist in opening twelve consoles?

Connect once. Compose agents. Talk from anywhere.

Everything in Agent Smith is built from three pieces: resources, secrets and agent profiles. Configure them in the dashboard's setup wizard, through the REST API, or with an SDK.

1. STEP 1

   Add your resources

   Pick a connector, point it at a target (an SSH host, a PostgreSQL server, an S3 bucket, a Kubernetes cluster) and run Test Connection. One resource can serve many agents.

2. STEP 2

   Seal the credentials

   Passwords, keys and tokens go into an encrypted vault, bound to the resource's secret slots. They resolve at execution time and are never part of a tool argument or a prompt.

3. STEP 3

   Build an agent profile

   Choose a model, then bind resources with an alias and an access mode: prod-db as ReadOnly, web-01 as ReadWriteWithApproval. Add instructions and runbooks.

4. STEP 4

   Put it to work

   Chat in the dashboard, publish a standalone chat page, or connect Claude Code, your own app or another agent over MCP, A2A, REST, the SDKs or the OpenAI-compatible API.

Twenty connectors across the systems you actually run.

Each connector ships purpose-built tools, so the agent asks for k8s_logs or sql_activity instead of improvising shell one-liners. Connector schemas drive the resource forms, secret slots, connection tests and tool definitions.

Missing a system? The connector contract is a small, documented interface. Read the connector authoring guide.

The server decides. Not the model.

Every tool call is classified as Read, Write or Destructive before it runs. A SELECT is Read, an UPDATE is Write, a DROP or a service restart is Destructive, and anything Agent Smith can't parse is treated conservatively. The binding's access mode then decides what happens.

You hear that, Mr. Anderson? That is the sound of an approval request. Nothing destructive happens until you answer it.

Built for the people who carry the pager.

I hate this place, this zoo, this prison. Mostly the part where you SSH into four hosts to find one log line.

What people hand to Agent Smith.

Tell me, Mr. Anderson, what good is a pager if you are unable to see the problem?

Every surface, one server port.

MCP clients bring their own model and loop. Dashboard chat, standalone chat, A2A and the OpenAI-compatible endpoint run Agent Smith's hosted loop with the profile's configured model. Every example authenticates with a bearer token from POST /v1.0/token.

# get a session token, then add Agent Smith to Claude Code
$ HUGO_TOKEN=$(curl -s -X POST http://127.0.0.1:8800/v1.0/token \
    -H "x-email: anderson@hugo.local" -H "x-password: $PASSWORD" | jq -r .token)

$ claude mcp add --transport http hugo http://127.0.0.1:8800/mcp/Hugo \
    --header "Authorization: Bearer $HUGO_TOKEN"

# the model name is the agent profile
$ curl -s -X POST http://127.0.0.1:8800/v1.0/openai/v1/chat/completions \
    -H "Authorization: Bearer $HUGO_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{"model": "Hugo", "messages": [{"role": "user", "content": "What tables are in demo-db?"}]}'

from hugo_sdk import HugoClient

with HugoClient("http://127.0.0.1:8800") as client:
    client.login("anderson@hugo.local", "password")   # stores a bearer token
    secret = client.secrets.create({"name": "web-01-key", "kind": "Password", "values": {"password": "..."}})
    resource = client.resources.create({
        "name": "web-01", "connectorType": "ssh",
        "settings": {"host": "web-01.example.com", "port": 22, "username": "deploy",
                     "authMethod": "Password"},
        "secretBindings": [{"slotName": "password", "secretId": secret.id}],
    })
    profile = client.agent_profiles.create({"name": "ops", "displayName": "Ops"})
    client.agent_profiles.create_binding(profile.id, {
        "resourceId": resource.id, "alias": "web-01",
        "accessMode": "ReadWriteWithApproval",
    })

# each profile is an A2A agent with its own card
$ curl -s http://127.0.0.1:8800/v1.0/a2a/default/Hugo/.well-known/agent-card.json

Up and running in 5 minutes, in your stack.

All you need is Docker with Docker Compose. The start script creates your .env, generates keys, and brings up the server, dashboard and observability stack.