Key concepts¶
A short, plain-language vocabulary for the rest of the documentation. For what you can do with each, see Use cases; for full definitions of all terms, see the Glossary.
What's a Kiwi agent?¶
A Kiwi agent is a reusable configuration — a role you can talk to — defined by four things:
- System prompt — the instructions that define the agent's role: what it does, how it should behave, its tone, and its boundaries. This is the most important part; it shapes every response the agent gives.
- Model (LLM) — the large language model that powers the agent's reasoning. It is set per agent and can be overridden for a single conversation. See Model.
- Tools — the specific capabilities the agent is allowed to call, such as document retrieval, web search, code execution, or media generation. An agent only ever uses the tools it has been granted. See Tools.
- Memory — the conversation history the agent keeps within a session, so it retains context across turns and you can resume later. See Session and memory.
The same agent can be reused across many conversations and shared with a team, and it works identically in the web interface and over the API.
Model¶
The underlying AI model an agent uses to reason and respond. Every agent has a default model, which you can override for a single conversation. Kiwi supports models from OpenAI and Google Gemini today, with Anthropic (Claude) support coming soon; on supported models you can also set how much the model reasons before answering, trading speed for depth. The current catalog is in Supported models.
Tools¶
Tools are the concrete capabilities an agent can call — each does one specific job, and an agent only ever uses the tools it has been granted. The twelve built-in tools fall into five areas:
| Area | Tool | What it does |
|---|---|---|
| Media | generate_image |
Create an image from a prompt |
edit_image |
Edit an existing image from an instruction | |
generate_video |
Create a short video from a prompt | |
generate_audio |
Generate music or sound effects | |
caption_media |
Describe an existing image or video in words | |
| Files | retriever_search |
Find and quote the relevant passages from your files |
summarizer |
Condense long documents | |
| Spreadsheets | spreadsheet_schema |
Inspect a sheet's columns and shape |
spreadsheet_query_sql |
Answer questions over a sheet with read-only SQL | |
| Web | web_search |
Look things up on the public web |
web_scraper |
Fetch and read specific pages in full | |
| Code | code_interpreter |
Write and run Python on your data |
Beyond these twelve, new tools can be added through connectors (MCP) — see below and on Coming soon.
Connectors and MCP (coming)¶
A connector adds new tools to Kiwi beyond the built-in set. Connectors are built on the Model Context Protocol (MCP) — an open standard for connecting AI applications to external tools and data sources. Once a connector registers a tool, it joins Kiwi's tool catalog and any agent can be granted it, exactly like a built-in one — so a capability is added once and reused everywhere.
In Kiwi this runs in two directions:
- External tools — bring in capabilities from third-party providers or an internal service your team already runs, so agents can act in systems beyond Kiwi.
- Module tools — each MRCL Make module exposes its own tools and actions through its own MCP server, so Kiwi agents can drive that module's features. This is what gives each module its agentic dimension (see Shared core).
Because every connector speaks the same protocol, the agent doesn't need to know whether a tool is built-in, external, or from a module — it calls all of them the same way. Self-serve connector management is being rolled out; for now, new connectors are set up with the Kiwi team. See Coming soon.
Data storage¶
Kiwi keeps your work so it remains available across sessions:
- Files you upload — documents, images, video, and audio — are processed (text and images extracted) and stored in the Library, ready to be grouped into collections and searched.
- Generated media is stored and returned as a shareable link.
- Conversation history is kept per session, so an agent remembers earlier turns and you can resume later.
Storage runs on managed enterprise cloud infrastructure; see Architecture for how it fits together and what keeps it secure.
Session and memory¶
A session is a conversation between a person and an agent. Kiwi keeps the conversation history, so the agent retains context across turns and the session can be resumed later. Each session can have its own attached documents.
Skill (coming)¶
A packaged set of instructions that teaches an agent how to carry out a specific task in a repeatable way, loaded only when it's needed. The distinction is simple: a tool is what an agent can do; a skill is how to do a particular task well. Defining your own skills is on the Coming soon list.
How a turn works¶
When you send a message, the agent reasons about it, acts by calling a tool if one is needed, observes the result, and repeats until it can answer — a pattern known as ReAct (reasoning and acting). The response is streamed as it is produced. Each request runs a single agent today; see What is Kiwi for how multiple agents are coordinated.
Related: Use cases · Architecture · Glossary