What Are Capabilities?

Capabilities are what make Selu agents useful beyond conversation. A capability is a small, self-contained service that an agent can call to interact with the outside world — fetch weather data, send emails, query databases, or control smart home devices.

How capabilities work

1. The LLM decides it needs to use a tool (based on the system prompt and conversation).
2. The orchestrator receives the tool call and looks up the matching capability.
3. The orchestrator sends a gRPC InvokeRequest to the capability’s container.
4. The capability executes the action and returns an InvokeResponse.
5. The orchestrator feeds the result back to the LLM to continue the conversation.

All of this happens in milliseconds. The user sees a seamless conversation — they don’t need to know that a Docker container just made an API call on their behalf.

Capability classes

Selu categorises capabilities into two classes based on their behaviour:

Tool

Stateless, request-response. The capability receives a request, does something, and returns a result. Most capabilities are tools — API lookups, calculations, data transformations.

Environment

Stateful, long-running. The capability maintains state across invocations within a session. Examples: a shell session, a browser instance, or a database connection pool. Environment capabilities get lifecycle hooks (start, stop) in addition to invoke.

The class is declared in manifest.yaml:

class: tool        # or "environment"

Note

Most developers start with tool capabilities. Only use environment when you genuinely need state that persists across multiple tool invocations within a single session.

Anatomy of a capability

Every capability lives in its own directory and contains:

File	Required	Purpose
manifest.yaml	Yes	Metadata, class, parameters, resource limits
prompt.md	No	Instructions appended to the agent’s system prompt
Dockerfile	Yes	Builds the container image
Source code	Yes	The gRPC server implementation (any language)

The gRPC interface is defined by capability.proto — a single service with an Invoke RPC. See gRPC Interface for the full spec.

Language support

Because capabilities communicate over gRPC, you can write them in any language with gRPC support:

• Python — Great for ML, data, and API integrations.
• Go — Fast startup, low memory overhead.
• Rust — Maximum performance, minimal container size.
• TypeScript/Node — Familiar for web developers.

Selu doesn’t care what’s inside the container, only that it speaks the capability.proto interface on port 50051.

Next steps

• manifest.yaml Reference — Full schema for capability manifests.
• gRPC Interface — The capability.proto contract.
• Example: Weather Agent — A complete, working capability walkthrough.