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

# Streaming Agents

> Run LLM-powered agents on your Kafka streams — process each record with a model and tools, validate against a schema, and write results back to a topic

<Info>
  **Beta.** Streaming Agents is in beta. The feature is in active development, and behavior may change. In the app it appears in the project sidebar as **Agentic**, marked *Beta*.
</Info>

A streaming agent is a Streamkap resource type alongside sources, destinations, pipelines, and transforms. It reads records from a Kafka topic, runs each one through an LLM (optionally calling tools), validates the result against a schema you declare, and writes the output to another topic. Records it can't process are routed to a dead-letter topic.

Agents are independent of sources and destinations. They bind to a Kafka **topic**, whichever way that topic was produced: by a source connector, a transform, another agent, or your own producer. Use them to classify, enrich, redact, or summarize streaming records in real time without hand-building a Kafka consumer and an LLM loop.

<Note>
  Not to be confused with [Agents](/agents), which covers connecting *external* AI assistants (Claude, Cursor, and others) to operate your Streamkap infrastructure via MCP, CLI, or REST. **Streaming Agents run inside Streamkap and process your streaming data.**
</Note>

## How It Works

1. An agent consumes records from **one** input Kafka topic.
2. For each record, it calls your chosen LLM with your system prompt and the record as input.
3. If the agent has tools, the model can call them and feed the results back to itself, looping until it produces a final answer (up to a maximum number of steps).
4. The response is validated against your optional output schema and written to the output topic.
5. Records that can't be processed — schema mismatch, tool failure, or unparseable output — are routed to a **dead-letter topic** (`dlq.<output-topic>`).

Every LLM and tool call runs on **your own credentials** — you bring an LLM connection (your provider API key), and all model usage is billed by your provider. Where available, Streamkap also provides managed **default connections** (an LLM and a vector store) so you can try your first agent without any keys — they're for quick tests, not production data. See [Streamkap Default Connections](/streaming-agents-connections#streamkap-default-connections).

## Where to Find It

Streaming Agents is a **project-level** feature. Open **Agentic** (*Beta*) in the project sidebar to reach it. The section is organized into tabs:

| Tab                  | What it's for                                                                                                                                         |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Overview**         | Fleet health, recent activity, and a setup checklist for your first agent                                                                             |
| **Agents**           | Create, deploy, and manage agents — see [Build an Agent](/streaming-agents-build) and [Manage Agents](/streaming-agents-manage)                       |
| **Knowledge Bases**  | Streaming embedding pipelines for retrieval — see [Knowledge Bases](/streaming-agents-knowledge-bases)                                                |
| **Observability**    | Traces, tool calls, and logs — see [Observability](/streaming-agents-observability)                                                                   |
| **Connections**      | Shared LLM, MCP, HTTP, and vector store credentials — see [Connections](/streaming-agents-connections)                                                |
| **Query Playground** | Ad-hoc SQL over your Kafka topics to inspect data before building an agent — see [Query Playground](/streaming-agents-observability#query-playground) |

## Key Concepts

* **Agent** — a deployed job that processes one input topic. Agents come in two shapes, selected automatically from whether you add tools:
  * **Workflow** — no tools; a single LLM pass per record (classify, summarize, redact).
  * **ReAct** — one or more tools; the model reasons, calls a tool, feeds the result back, and repeats until it produces an answer.
* **Connection** — a saved, encrypted credential shared across every agent in your organization: an LLM provider, an external MCP server, an HTTP endpoint, or a vector store. See [Connections](/streaming-agents-connections).
* **Tool** — something the model can call during a run: an **HTTP** request, a **Script** (JavaScript or Python), an **External MCP** server, or **Streamkap MCP** (the agent operating your Streamkap platform).
* **Knowledge Base** — a streaming pipeline that embeds a Kafka topic into a vector store so agents can retrieve from live data. See [Knowledge Bases](/streaming-agents-knowledge-bases).
* **Memory** — optional short-term (time-boxed) and long-term (vector store) context carried across records.
* **Dead-letter topic (DLQ)** — where unprocessable records land, derived as `dlq.<output-topic>`.

## Permissions

Access is controlled by two permissions on your Streamkap roles:

| Permission     | Grants                                                                                                                        |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `read:agents`  | View the Agentic section, agents, knowledge bases, observability traces and tool calls, and connections (secrets stay masked) |
| `write:agents` | Create, edit, deploy, and manage agents and knowledge bases; save connections; view logs; run knowledge base retrieval        |

The sidebar entry is hidden if you don't have `read:agents`. Read-only users can view the screens but write actions are disabled. If you don't see the feature or an action, ask an admin for the appropriate permission.

## Limits

| Limit                              | Value                  |
| ---------------------------------- | ---------------------- |
| Input topics per agent             | 1                      |
| Knowledge bases attached per agent | 10                     |
| Max reasoning steps (ReAct)        | 25                     |
| Custom instructions                | 8,000 characters       |
| Filter SQL                         | 4,000 characters       |
| Config versions retained           | 50 per agent           |
| Preview run                        | 15 seconds, one record |

## Next Steps

<CardGroup cols={2}>
  <Card title="Connections" icon="key" href="/streaming-agents-connections">
    Set up the LLM, MCP, HTTP, and vector store credentials agents use.
  </Card>

  <Card title="Build an Agent" icon="robot" href="/streaming-agents-build">
    Walk through the deploy wizard, preview a run, and go live.
  </Card>

  <Card title="Manage Agents" icon="sliders" href="/streaming-agents-manage">
    Lifecycle, savepoints and offsets, config history, and the DLQ.
  </Card>

  <Card title="Knowledge Bases" icon="database" href="/streaming-agents-knowledge-bases">
    Stream a topic into a vector store for retrieval.
  </Card>

  <Card title="Observability" icon="chart-line" href="/streaming-agents-observability">
    Traces, tool calls, logs, and the query playground.
  </Card>
</CardGroup>