> This page is also available as Markdown: append .md to its URL. The full index of Sikaru docs is at https://docs.sikaru.ai/llms.txt. Code examples use only operations from the public API reference at https://docs.sikaru.ai/api-reference.

# Build, run, and improve agents with Sikaru

Define what an agent should do, give it the tools it needs, and send it work. Sikaru runs the agent, keeps its execution state, and gives your application events, results, and evidence of what happened.

Use it for a support assistant that investigates cases, a research agent that writes reports, or an operations agent that works with your team's tools.

#### [Run your first agent](/get-started/quickstart)

Create an agent from instructions, submit a task, and read its result.

#### [Understand the building blocks](/get-started/core-concepts)

How projects, agents, releases, sessions, and runs fit together.

#### [Connect your application](/run/sessions-and-steering)

Continue conversations and steer work already in progress.

#### [Inspect execution](/improve/trace-ingestion)

Read managed run evidence, or bring traces from an agent you already run.

## Who does what

| Your application         | Sikaru                                  |
| ------------------------ | --------------------------------------- |
| The customer experience  | The agent loop                          |
| Approval decisions       | Context and retained state              |
| Tenant and user identity | Recovery after failures                 |
| Where results are shown  | Events, results, and execution evidence |

## How it works

```mermaid
flowchart LR
    Definition["Agent instructions and tools"] --> Release["Agent release"]
    Release --> Session["Session"]
    Task["Your application's task"] --> Session
    Session --> Run["Managed run"]
    Run --> Tools["Allowed tools"]
    Tools --> Run
    Run --> Result["Output, files, and events"]
    Run --> Evidence["Execution evidence"]
```

#### Define an agent

Write its instructions and choose its tools. Each saved version is an immutable **release**.

#### Open a session

A session is one conversation. It keeps its own context and pins one release.

#### Send work

Each task becomes a **run**. The run calls only the tools the agent is allowed to use.

#### Read results and evidence

Read output, files, and events as the run progresses. Inspect execution evidence afterwards.

One agent serves many users. Store the session and run IDs in your application so you can reconnect, inspect results, and continue the right conversation.

## What you can build

| Need                                    | Sikaru capability                                            | Start here                                            |
| --------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------------- |
| Respond to a task in your product       | Start a run and consume its events                           | [Runs and tool requests](/run/runs-and-tool-requests) |
| Continue work across messages           | Keep a session; steer active work or queue another turn      | [Sessions and steering](/run/sessions-and-steering)   |
| Use an external application or API      | Grant connection tools or handle product-owned tool requests | [Tools and connections](/build/tools-and-connections) |
| Work with documents and generated files | Upload inputs and retrieve session artifacts                 | [Files and artifacts](/run/files-and-artifacts)       |
| Work on a machine you control           | Attach a native executor to a local workspace                | [Local compute](/run/local-compute)                   |
| Run recurring tasks                     | Configure schedules and observe admitted work                | [Schedules](/run/schedules)                           |
| Assess and improve behavior             | Evaluate retained traces and review candidate releases       | [Evaluations](/improve/evaluations)                   |

> **Note**
>
> Optional capabilities depend on your project's permissions and service configuration. Start with a small task, inspect the evidence, then add tools and automation.

## Choose your interface

#### Dashboard

Work with agents and inspect conversations.

#### [SDKs and REST API](/sdks-and-cli/sdks)

Integrate execution into your application in Python or TypeScript.

#### [CLI](/sdks-and-cli/cli)

Terminal workflows, scripts, and local compute.

#### [Your coding agent](/get-started/use-with-ai-agents)

Give Claude Code, Codex, or Cursor these docs and the authoring skill.

Your backend authenticates with a Sikaru project API key. You do not need model-serving credentials to run a managed agent. Pick a supported catalog model or use the project default; see [Models and output](/build/models-and-output).

Already running an agent elsewhere? [Submit its traces](/improve/trace-ingestion) without moving execution first. Trace ingestion and managed execution are separate entry points.

Next: the [Quickstart](/get-started/quickstart), or the [agent lifecycle](/get-started/agent-lifecycle) for the complete journey.