Use cases¶

What you can actually get done with a Kiwi agent and its built-in tools. Each use case below is something an agent does in an ordinary conversation — one agent, calling the tools it needs, with the whole exchange kept in session memory so you can refine across turns. The tools each relies on are named so you know what to enable on the agent.

Generate media content with the agent and media tools¶

Use an agent to produce media as part of a larger task, not as a separate step. In a single conversation the agent can reason about a brief, draft the copy or concept, and then generate the matching visual or clip — calling Media Studio tools mid-conversation and streaming each result back as it is made. Because the session keeps memory, you iterate in place: adjust the tone, change the format, or spin a variant without re-explaining the context.

That is the difference between a one-shot generator and an agent: it decides when media is needed, generates it with the right settings, and folds it into the rest of the work.

Concept to key art — describe a campaign idea, have the agent propose directions, then render the hero image for the one you pick.
Storyboard a clip — turn a short script into a sequence of frames, then a short video.
Iterate in place — "make it warmer," "now a 9:16 version," "swap the background" — each over the previous result.

Draft three lines of launch copy for a summer drink, then generate a bright, square hero image to match the winning line.

Tools: generate_image, generate_video, generate_audio

Analyze documents and assets¶

Give an agent your own files and have it answer from them, with references back to the source. Upload files to the Library, group them into a collection, and attach it to an agent, a session, or a single message. When you ask a question, the agent retrieves the most relevant passages and grounds its answer in them, citing where each point came from. This is a RAG-like approach. It can also condense long files to the length and depth you want.

Because answers are grounded in your material and cite it, you can trust and check them — which matters for contracts, policies, specifications, and research.

Answer from policies — ask what a clause means or what the rules are, and get an answer that quotes the exact passage.
Summarize a stack of files — turn several long PDFs into a short, sourced briefing.
Compare versions — ask what changed between two drafts of a document.
Ground an assistant — point an agent at your product docs so it answers accurately and on-brand.

Across these three contracts, what are the termination notice periods, and which is the strictest? Quote each clause.

Tools: retriever_search, summarizer

Extract structured data from files¶

Point an agent at a stack of files — invoices, contracts, reports, forms — and have it pull the same fields out of each one into a single, clean table, with a reference back to the source for every value. Instead of reading each file by hand, you describe the columns you want and the agent fills them in across the whole set.

It builds on document grounding: the agent retrieves the relevant passages and the model turns them into structured rows. Hand the result to code to chart it, or to spreadsheets for further querying.

Contracts — pull counterparty, effective date, renewal terms, and notice periods into one row each.
Invoices — extract vendor, amount, date, and line items across a folder.
Forms and reports — turn many similar documents into one comparable table.

From these twelve contracts, build a table with the counterparty, effective date, term length, and termination notice — one row per contract, and cite the clause for each.

Tools: retriever_search

Research the web¶

When a question needs current or external information, let the agent reach the public web. It searches for the most relevant results and reads specific pages in full, then works from what it finds. You control access per conversation — switch the web off to keep the agent grounded only in your own material.

Market and competitor scan — gather and summarize what's published on a topic.
Fact-check — confirm a detail against current sources.
Read long articles — pull the clean text from specific pages for the agent to work with.

Find the three most recent announcements from our main competitor and summarize what changed, with links.

Tools: web_search, web_scraper

Generate media (image, video, audio)¶

Media Studio produces media from natural-language descriptions, available to any agent as built-in tools. You describe what you want and adjust a few settings — model, aspect ratio, resolution, duration (for video), quality, and style — and the result comes back as a shareable link, ready to drop into a product or a deck.

Images — generate from a prompt (generate_image).
Video — generate short clips (generate_video); animate a single frame, or transition between two.
Audio — generate music or sound effects (generate_audio).
Captioning — describe an existing image or video in words (caption_media), for accessibility or search.

A 16:9, 1080p establishing shot of a calm seaside town at sunrise, soft warm light.

The full list of media models and their options is in Supported models.

Tools: generate_image, generate_video, generate_audio, caption_media

Analyze large spreadsheets¶

Upload a large Excel or CSV file and ask questions in plain language — no formulas required. The agent first inspects the sheet's structure, then answers by running safe, read-only SQL over your data, so your file is never changed. Results come back as tidy tables inline, and you can keep drilling in across turns.

Sales analysis — find the products, regions, or periods with the biggest changes.
Spot outliers — surface unusually high or low rows in a large export.
Compare segments — line up markets, periods, or categories side by side.
Quick totals — sums, averages, and counts without writing a formula.

From this export, which five SKUs grew most quarter-over-quarter, and what is each one's margin?

For anything that needs custom logic or charts, the agent can switch to code on the same data.

Tools: spreadsheet_schema, spreadsheet_query_sql

Generate plots and run data analysis¶

When a question needs real computation, the agent writes and runs Python in an isolated sandbox — safely away from your own systems. Pass files in and get files back: a cleaned dataset, a converted document, or a chart. It pairs naturally with spreadsheets — query the data first, then compute or plot it in code.

Make a chart — turn a table into a clear visualization.
Clean and reshape — fix a messy export and get a tidy file back.
Convert formats — reshape or convert a file from one format to another.
One-off calculations — run a computation that's awkward to do by hand.

Plot monthly revenue from this CSV as a line chart, and flag any month that dropped more than 10%.

Tools: code_interpreter

Edit images¶

Refine an image instead of regenerating it from scratch. Once an image exists, edit it by instruction (edit_image), or open the visual editor to annotate specific regions and regenerate just those areas — keeping the rest of the image intact. This is the tool for small fixes and controlled changes, where a fresh generation would lose what already works.

Fix a detail — change a colour, remove an object, or adjust the background.
Localized change — annotate one region and regenerate only that part.
Variants — branch a few options from an approved base image.

Keep this product shot, but change the backdrop to warm beige and remove the reflection on the left.

Tools: edit_image

Combine these¶

These use cases are building blocks, not silos. A single agent can chain them in one session — analyze a spreadsheet, run code to chart the result, pull supporting facts from the web, draft the copy, and generate the campaign image — because every tool is available to the same agent across one conversation, with memory carried throughout.

From this sales export, chart the top regions, pull two recent market stats from the web, then draft a one-paragraph summary with a matching hero image.

Related: Tools · Supported models · Getting started