> ## Documentation Index
> Fetch the complete documentation index at: https://docs.komodor.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Interfaces

> Every way to work with the platform — console, REST API, SDKs, MCP, and Slack — and when to reach for each.

There is more than one way to drive the Komodor Agentic Operation Platform (KAOP), and picking the
right one saves a lot of effort. This page maps every interface, says who each is for, and links to
its deeper documentation. Skim it once so you know what exists.

## At a glance

| Interface       | Use it to                                                                | Who reaches for it                       |
| --------------- | ------------------------------------------------------------------------ | ---------------------------------------- |
| **Web console** | Build agents, watch runs, operate modules, manage access                 | Everyone — the primary surface           |
| **REST API**    | Automate anything the console does                                       | Platform engineers, CI, internal tooling |
| **Python SDK**  | Author agent workers                                                     | Agent developers                         |
| **Go SDK**      | Author agent workers with no Python in the container                     | Agent developers on Go                   |
| **MCP server**  | Let an agent or coding assistant inspect the workspace and invoke agents | Agents, Claude Code / Cursor / Codex     |
| **MCP Gateway** | Expose *your* tools to agents                                            | Platform engineers                       |
| **Slack**       | Invoke agents and receive results where the team already works           | On-call and responders                   |

## The web console

Everything KAOP does is available in the console: building and deploying agents, reading runs and
their evidence, operating modules, connecting integrations, and managing identity and access. It
is served as its own application and talks only to the control plane, so console and backend
releases are independent.

## The REST API

The primary programmatic surface, under `/api/v1`. Anything the console does is available here —
agents, runs, chat, triggers, schedules, webhooks, workflows, integrations, credentials, and
evidence.

```bash theme={null}
curl -H "Authorization: Bearer $KAOP_API_KEY" \
  "$AGENTOPS_URL/api/v1/agents"
```

Interactive reference documentation is served at `/api/docs` on your workspace host. See
[APIs](/developer-tools/apis).

<Note>
  Requests authenticate with a token and receive a JSON `401` when unauthenticated. Browser sessions
  use SSO instead — see [Signing in](/security-and-governance/identity-and-access/signing-in).
</Note>

## The SDKs

An agent's behavior lives in a **worker** you write and run. The SDK handles the protocol —
registration, receiving work, and streaming evidence back — so your code can be about the agent.

<CardGroup cols={2}>
  <Card title="Python SDK" href="/developer-tools/python-sdk">
    `komodor-agentops`. The primary authoring path, whatever agent framework you build on.
  </Card>

  <Card title="Go SDK" href="/developer-tools/go-sdk">
    A native Go worker SDK for teams who would rather not ship a Python runtime.
  </Card>
</CardGroup>

## MCP: two different things

Both use the Model Context Protocol, and they point in opposite directions — worth keeping
straight.

|                | **The KAOP MCP server**                     | **The MCP Gateway**                                    |
| -------------- | ------------------------------------------- | ------------------------------------------------------ |
| Direction      | Something reaches *into* KAOP               | Agents reach *out* to your tools                       |
| Purpose        | Inspect the workspace, invoke agents safely | Expose an MCP server or OpenAPI surface as agent tools |
| Typical client | An agent, or a coding assistant             | Your own tool surface                                  |
| Docs           | [MCP server](/developer-tools/mcp-server)   | [MCP Gateway](/manage-your-agents/build/mcp-gateway)   |

**Coding assistants** connect over the MCP server: Claude Code, Cursor, and Codex can query your
workspace and invoke agents from your editor. See
[Connect coding agents](/developer-tools/connect-coding-agents).

## Slack

Connect Slack and people invoke agents from a channel and get results in the thread. Routing rules
decide what each inbound message does — an agent, a workflow, or an incident pipeline can be the
target. See [Channels](/manage-your-agents/run/channels).

## Agent-to-agent invocation

Agents can invoke other agents through the control plane, which keeps the call authorized and
recorded like any other run rather than becoming an unobserved side channel. See
[Orchestration](/manage-your-agents/run/orchestration).

## Next steps

<CardGroup cols={2}>
  <Card title="Architecture" href="/get-started/architecture">
    How these surfaces sit around the control plane.
  </Card>

  <Card title="Developer tools" href="/developer-tools/overview">
    The programmatic surfaces in depth.
  </Card>
</CardGroup>


## Related topics

- [Control plane](/get-started/architecture/control-plane.md)
- [Architecture](/get-started/architecture.md)
- [Before you begin](/get-started/before-you-begin.md)
- [Data flow](/get-started/architecture/data-flow.md)
- [Concepts & glossary](/get-started/concepts.md)