# Concepts Overview

> Everything in inference shell connects to help you get work done with AI.

**URL:** https://inference.sh/docs/concepts
**Last updated:** 2026-09-18

---

Everything in inference shell connects to help you get work done with AI.

---

## The Building Blocks

```
┌─────────────────────────────────────────────────────────────────┐
│                                                                  │
│    You  ──▶  Agent  ──▶  Tools (Apps & Flows)  ──▶  Result     │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘
```

### Apps

**Apps** are the building blocks. Each app does one thing well:

- Generate an image
- Transcribe audio
- Analyze text
- Process data

Apps have typed inputs and outputs. You fill in the inputs, run the app, and get results.

Browse 100+ apps in the **Grid**, or create your own. Use [Search](/docs/concepts/search) or the [Search API](/docs/api/rest/search) to discover apps, skills, and knowledge programmatically. Agents can additionally use **connector integrations** (OAuth-managed services) as tools — see [Tool Orchestration](/docs/runtime/tool-orchestration).

### Tasks

**Tasks** are what happens when you run an app. Every execution creates a task that:

- Tracks progress in real-time
- Shows logs and status updates  
- Stores inputs and outputs
- Can be cancelled if needed

### Flows

**Flows** chain multiple apps together visually:

```
Input ──▶ App A ──▶ App B ──▶ App C ──▶ Output
```

- Build in a visual editor
- Connect outputs to inputs
- Deploy as a single app
- Give agents multi-step capabilities

### Agents

**Agents** are AI assistants that can use apps and flows as tools:

- You describe what you want
- The agent plans the steps
- It picks and runs the right tools
- You get the result

Agents can even generate UI widgets when they need more information from you.

### Workers & Engines

Behind the scenes, **workers** actually run your tasks:

- **Cloud workers** — Managed by inference shell, pay-per-use
- **Private workers** — Run on your own hardware via an **engine**

You choose where things run. Your data, your rules.

### Sessions

**Sessions** lease one worker for multiple related calls so state can persist in memory (browser automation, interpreters, multi-step interactive apps). Stateless runs use a fresh worker each time.

→ [Sessions](/docs/concepts/sessions) — when to use sessions, lifecycle, timeouts

---

## Core concepts (detail)

| Topic | Guide |
|-------|--------|
| Apps | [concepts/apps](/docs/concepts/apps) |
| Tasks | [concepts/tasks](/docs/concepts/tasks) |
| Flows | [concepts/flows](/docs/concepts/flows) |
| Agents | [concepts/agents](/docs/concepts/agents) |
| Workers | [concepts/workers](/docs/concepts/workers) |
| Sessions | [concepts/sessions](/docs/concepts/sessions) |
| Search | [concepts/search](/docs/concepts/search) |

---

## How They Connect

```
┌─────────────────────────────────────────────────────────────────┐
│                          Agent                                   │
│                                                                  │
│    "Generate a logo and resize it for social media"             │
│                              │                                   │
│                              ▼                                   │
│    ┌─────────────────────────────────────────────────────┐      │
│    │                     Planning                         │      │
│    │  1. Generate logo with image-gen app                │      │
│    │  2. Resize for each platform with image-resize flow │      │
│    └─────────────────────────────────────────────────────┘      │
│                              │                                   │
│              ┌───────────────┴───────────────┐                  │
│              ▼                               ▼                   │
│        ┌──────────┐                   ┌──────────┐              │
│        │ App:     │                   │ Flow:    │              │
│        │ DALL-E   │ ────────────────▶ │ Resize   │              │
│        └──────────┘                   └──────────┘              │
│              │                               │                   │
│              ▼                               ▼                   │
│         [Task 1]                     [Tasks 2-5]                │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘
```

1. You tell the **agent** what you want
2. Agent **plans** the steps
3. Agent calls **apps** or **flows** as tools
4. Each execution creates **tasks**
5. Tasks run on **workers**
6. You get the result

---

## What's Next?

- [**Agents**](/docs/agents/overview) — Start building assistants that work for you
- [**Apps**](/docs/apps/overview) — Explore the Grid and run tools
- [**Flows**](/docs/flows/overview) — Chain apps into workflows