---
title: "Concepts Overview"
description: "The conceptual map of Meerkat: composability, identity, lifecycle, capabilities, and orchestration."
icon: "compass"
---

Meerkat is easiest to understand as a **composable agent runtime** with a practical product layer on top.

You can approach it from any surface:

- Rust embedding
- Python or TypeScript SDKs
- CLI
- REST / JSON-RPC / MCP
- multi-agent orchestration

The core concepts fit together like this:

```mermaid
flowchart TD
    C["Composability"] --> R["Realms"]
    R --> S["Sessions"]
    R --> CFG["Configuration"]
    C --> P["Providers"]
    C --> T["Tools"]
    T --> M["Memory & Compaction"]
    T --> H["Hooks"]
    T --> SK["Skills"]
    C --> CB["Comms"]
    CB --> MB["Mobs"]
    C --> SCH["Scheduling"]
    C --> RT["Live Channels"]
    R --> AB["Auth & Bindings"]
```

## Read order

If you are new to Meerkat, a good concepts path is:

1. [Composability](/concepts/composability)
2. [Realms](/concepts/realms)
3. [Sessions](/concepts/sessions)
4. [Configuration](/concepts/configuration)
5. [Providers](/concepts/providers)
6. [Tools](/concepts/tools)

Then branch into the systems you need:

- [Auth & bindings](/concepts/auth-and-bindings)
- [Memory & compaction](/concepts/memory-and-compaction)
- [Comms](/concepts/comms)
- [Mobs](/concepts/mobs)
- [Scheduling](/concepts/scheduling)
- [Live Channels](/guides/realtime)

## What each concept owns

| Concept | Main question |
|---------|---------------|
| `Composability` | What kind of product is Meerkat, and why do the surfaces behave like peers? |
| `Realms` | What defines shared vs isolated state? |
| `Sessions` | How does one conversation live, continue, and end? |
| `Configuration` | How are runtime settings stored and updated? |
| `Providers` | How are models resolved, selected, and capability-gated? |
| `Tools` | How does the agent act on the world? |
| `Auth & bindings` | Under what identity/credentials does the runtime talk to a provider? |
| `Memory & compaction` | How does Meerkat handle context beyond one model window? |
| `Comms` | How do long-lived agents exchange messages? |
| `Mobs` | How does Meerkat coordinate multiple agents as one system? |
| `Scheduling` | How does durable automation fire over time? |
| `Live Channels` | How does low-latency interactive transport fit into the session model? |

## Where To Go Next

After the core concepts, choose the path that matches the system you are
building:

| Path | Start with |
|------|------------|
| Embedding Meerkat in Rust | [Rust SDK overview](/rust/overview) |
| Driving Meerkat from an app | [Python SDK](/sdks/python/overview) or [TypeScript SDK](/sdks/typescript/overview) |
| Running Meerkat as a service | [JSON-RPC](/api/rpc) or [REST](/api/rest) |
| Building multi-agent systems | [Mobs](/guides/mobs) |
| Running private models | [Self-hosting models](/guides/self-hosting-models) |
| Understanding ownership | [Architecture](/reference/architecture) |

## See also

- [Introduction](/introduction)
- [Quickstart](/quickstart)
- [Examples gallery](/examples/gallery)
- [Architecture](/reference/architecture)
