Most agent demos end with a wall of text. The agent searches, reasons, summarizes, and then dumps its findings into a chat window that nobody will ever look at again. But in real teams, research does not end in a chat log. It ends in a deliverable, and more often than not that deliverable is a slide deck.
In this tutorial we will build a small research agent that closes that gap. The agent will:
- Pull live data through AIsa's unified API gateway (web search plus market data)
- Use a model through AIsa's model gateway to synthesize the findings into a structured slide outline
- Hand the outline to an AI presentation maker that turns it into a finished, designed deck
The whole pipeline is about 80 lines of Python, and because every external call goes through AIsa, you manage exactly one API key.
Why route everything through one gateway
A research agent typically needs three or four vendor accounts before it does anything useful: a search API, a data API, an LLM provider, and billing for each. AIsa collapses that into a single endpoint. The model gateway is OpenAI-compatible, so most existing agent code works after swapping the base URL, and the skills layer exposes search and data providers like Tavily, Twitter, and CoinGecko behind the same key.
That matters for this tutorial because the agent makes heterogeneous calls (search, market data, LLM completion) and we want the code to read like one system, not three SDKs stapled together.
Step 1: Set up the client
Create an AIsa account, generate an API key in the console, and point an OpenAI-compatible client at the gateway:
That is the only credential the agent will use.
Step 2: Gather the research
Suppose the deck we need is "State of AI agent infrastructure, July 2026" for a Monday stakeholder meeting. The agent first collects raw material through AIsa's search skill:
Each result comes back with a title, URL, and content snippet. Keep the URLs. A deck built for stakeholders should cite its sources, and we will carry them all the way through to the final slides.
Step 3: Synthesize a slide outline, not a summary
Here is the part most people get wrong. If you ask the model to "summarize the research," you get prose, and prose makes bad slides. Instead, ask for a structured outline with a fixed schema: one object per slide, each with a title, three to five bullet points, and the source URLs that support it.
Two practical notes from building this:
- Cap the bullet length in the prompt. Twelve words per bullet is roughly what survives on a real slide. Without the cap, models write sentences, and sentences on slides read like a document projected on a wall.
- Force the sources through. Requiring a
sourcesarray per slide keeps the model honest and gives the deck a citations slide for free.
Step 4: Hand off to the presentation layer
Now the agent has a clean, structured outline. The last step is turning it into something a human will actually present, with layout, theme, charts, and speaker notes. This is a design problem, not a reasoning problem, and it is the wrong place to hand-roll code. Generating raw PPTX from a library gets you unstyled boxes; what you want is a generation step that makes design decisions.
We write the outline to a document and pass it to ChatSlide, an AI slides tool for research that accepts a topic, an outline, or an uploaded document and produces a themed, editable deck from it:
Upload outline.md (or paste it), pick a theme, and the generator lays out each section as a designed slide, adds visuals, and keeps everything editable for the final human pass. Because the outline already has the right granularity (one section per slide, short bullets, sources attached), the generated deck needs minutes of polish instead of an afternoon.
The pattern that generalizes
Strip away the specifics and the architecture is:
- Acquire through one gateway (AIsa skills for search and data)
- Structure with a schema-constrained LLM call (slide outline as JSON)
- Render with a specialized generation tool (deck, report, or video)
The middle step is the load-bearing one. Agents that pass unstructured prose between stages accumulate noise; agents that pass schemas compose cleanly. And the same pipeline extends naturally: swap the search queries and the rendering target, and the identical skeleton produces market reports, competitor briefs, or weekly metrics reviews.
The agentic economy is usually described in terms of machine-to-machine transactions, and AIsa's payments layer points to where that is heading: an agent that pays per call for its own research and hands you a finished deck before your Monday meeting. The infrastructure for the first half already exists. As this tutorial shows, the second half does too.
This tutorial was contributed by the team at ChatSlide, an AI presentation and video generator used by over 220,000 people.