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, and each does one specific job. By default, an agent receives all built-in tools and automatically receives new ones. Agents that need tighter control can use an explicit tool list. Connector tools are always explicitly assigned. Built-in tools fall into these areas:

Area	Tool	What it does
Documents	`file_read`	Read exact text from an accessible file
	`pdf_annotations_read`	Read comments and annotations extracted from a PDF
	`retriever_search`	Find and quote the relevant passages from your files
	`summarizer`	Condense long documents
Data	`run_in_sandbox`	Write and run code on your data in a hosted sandbox
	`smart_search`	Search configured structured business data using natural language
Skills	`load_skill`	Load the instructions for an assigned skill when needed
	`read_skill_resource`	Read supporting text bundled with a loaded skill
Media	`generate_image`	Create an image from a prompt, optionally conditioned on source images for edits or reference-guided generation
	`generate_video`	Create or edit short videos from prompts, images, or videos
	`generate_music`	Generate music
	`generate_sound_effect`	Generate sound effects
	`generate_speech`	Generate spoken audio from text
	`caption_media`	Describe an existing image or video in words
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

This table follows the current native tool registry. The live catalogue is the source of truth as tools are added or changed. Additional tools can be added through Connectors and MCP.

Audio tool migration

generate_audio has been replaced by generate_music, generate_sound_effect, and generate_speech. Agents that still use generate_audio should update their tooling.

Connectors and MCP¶

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.
Future module tools — the planned rollout gives each MRCL Make module its own MCP server so Kiwi agents can drive that module's features. This is part of each module's 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. Connectors are available when the feature is enabled for your deployment; management may be exposed through an integration rather than the web interface. See Connectors and MCP.

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 Security and data handling for where information is stored, when it is sent to another service, and what users should consider before sharing it.

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¶

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. See Skills for use, sharing, and safety guidance.

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 · Skills · Connectors and MCP · Glossary