AI Blocks

The AI blocks are the platform’s AI-native infrastructure. Each does one thing, and they compose: a bot retrieves from knowledge, calls models through the gateway, remembers through memory, and delegates long-running work to a flow.

The blocks

Block	What it does
AI Gateway	Every model call goes through here — aliasing, fallback, budgets, caching, prompt registry, cost accounting
AI Flow	Flows as DAGs of tasks, agentic harnesses with bounded loops, and a library of built-in AI tasks
AI Bot	Conversational infrastructure with a cost-escalating NLU cascade
AI Knowledge	Lexical, semantic and hybrid retrieval over your corpus
AI Memory	Short- and long-term memory, with compaction and decay
AI Evals	Measure quality, and gate deploys on it

How they fit together

                        ┌──────────────────────────────┐
       your app ───────▶│           AI Bot             │
                        │  conversation, NLU cascade   │
                        └──┬────────┬────────┬─────────┘
                           │        │        │
              retrieval ───┘        │        └─── multi-step work
                    │               │                   │
                    ▼               │                   ▼
            ┌───────────────┐       │           ┌───────────────┐
            │ AI Knowledge  │       │           │    AI Flow    │
            └───────┬───────┘       │           └───────┬───────┘
                    │        recall │                   │
                    │               ▼                   │
                    │       ┌───────────────┐           │
                    │       │   AI Memory   │           │
                    │       └───────┬───────┘           │
                    │               │                   │
                    └───────────────┼───────────────────┘
                                    │  every model call
                                    ▼
                        ┌──────────────────────────────┐
                        │          AI Gateway          │
                        │   budgets · cache · audit    │
                        └──────────────┬───────────────┘
                                       ▼
                        Anthropic · OpenAI · vLLM · local models

The important edge is the bottom one. Every model call in every block routes through the AI Gateway — bot cascades, flow tasks, knowledge embeddings, memory compaction. That is what makes per-tenant cost accounting, budgets and a single audit trail possible, and it is why no block holds a provider credential of its own.

Where to start

Building a conversational product? Start with AI Bot. Its cascade is the difference between a demo and something you can afford to run at volume.

Automating multi-step work? Start with AI Flow — author a DAG, submit requests over HTTP, run it on a fleet of agents. When the steps depend on what the model finds along the way, reach for a harness instead: same format, plus bounded loops that the compiler refuses to build without a budget.

Adding search or RAG? Start with AI Knowledge, and use hybrid retrieval until you have evidence you need otherwise.

Just want model access with guardrails? AI Gateway is usable on its own — point an existing OpenAI or Anthropic SDK at it and get aliasing, fallback and budgets without changing your integration.