Skip to content

The Core model

Core is a platform for building solutions with language models for your customers. Each customer gets an organisation of its own. Inside that organisation you define what an agent knows, what it may do and which model it works with, and your application calls it with a key.

The building blocks

Building block What it is Read on
Organisation one customer's closed-off space: its own administrators, keys, agents, knowledge, data, usage and caps Organisations and customers
Keys and policy how an application identifies itself, and what that key reaches Keys, capabilities and policy
Agents the AI that reasons and acts: a model, instructions, a prompt, skills and tools, stored under a name Agents
Knowledge what an agent can know: documents in collections, made searchable in an index or a graph Knowledge
Tools what an agent can do: call an API, search the web, run code, hand work to another agent Tools
MCP a way to connect external tools, and to offer Core itself as tools MCP
Models what an agent thinks with: the catalogue, regions, fallback, routers and prices Models and routing
Usage, Audit and Traces seeing what happened and what it cost Insight
Publications building something once and installing it at several customers Sharing and reuse

How it fits together

flowchart TB
    app["Your application"] -->|"request with a key"| key
    subgraph org["Organisation: one customer's space"]
        key["Keys and policy<br/>who may do what"]
        agent["Agents<br/>reasons and acts"]
        knowledge["Knowledge<br/>what the agent knows"]
        tools["Tools<br/>what the agent does"]
        models["Models<br/>what the agent thinks with"]
        insight["Usage, Audit, Traces<br/>what happened"]
        key --> agent
        agent --> knowledge
        agent --> tools
        agent --> models
        agent -.-> insight
    end
    pub["Publications<br/>reuse at other customers"] -.->|"copies"| org

A request passes through the blocks in this order:

  1. Your application sends a request with a key. The key belongs to exactly one organisation, and everything the request touches after that belongs to that organisation.
  2. Core checks the request against the key's capabilities and policy: is the feature on, and may this key reach this model, this tool and this knowledge?
  3. The request names an agent, or describes the model, instructions and tools itself. The agent is the stored form of the same thing.
  4. The model answers, or asks for a tool. A search tool over knowledge is a tool too: that is how the content of your documents ends up in the answer.
  5. Core records what happened: usage per key and per person, audit events per decision, and a trace per model call.

An example. You build a support assistant for the customer Noordwind. Noordwind is an organisation under yours. It holds a collection with the handbook, an index over it and a search tool knowledge__handbook. An API connector gives access to the ticket system. The agent support stores the model, the instruction and those two tools. Noordwind's application sends {"agent": {"id": "support"}, "input": "..."} with one of Noordwind's keys. When your next customer needs the same assistant, you publish the agent and install it there.

What an organisation does not share

Organisations share nothing by themselves. One of Noordwind's keys sees no agent, document or usage record of another customer, nor of your own organisation. Reuse is something you do on purpose, with a publication. As an administrator of the organisation above, you do manage the customer organisation: its keys, caps and settings (Organisations and customers).

Next

You want to Read
understand how to lay out your customers Organisations and customers
build a product of your own with Core underneath Building a platform on Core
send a first request Make your first call
build something that works, step by step Tutorials
get to know the console Use the console
create a customer organisation Manage organisations in the console or with a key
store an agent Agents through the API
make documents searchable Knowledge through the API
connect a tool Tools through the API
look up the API API reference