Under the Hood: How TruGen Turns Your Deck into a Presenting Agent

When you upload a deck to TruGen's visual presentations, the agent doesn't just attach a file. By the time a user asks their first question, every slide has been parsed, understood, and indexed - so the agent can pull up the exact pricing table or architecture diagram mid-conversation, while it speaks.

This post walks through what happens between upload and that first presented slide.

1. Upload - you add a PDF or PowerPoint deck (up to 100 MB) in the Studio or via the API.

2. Parse - each document is split into its atomic unit: pages for PDFs, slides for PPTX.

3. Extract - an intelligent content extraction engine reads structure and meaning from every slide.

4. Index - the proprietary knowledge base engine turns extracted content into a searchable index.

5. Retrieve and present - at query time, the agent semantically matches the question to a slide, then speaks the answer and shows the slide together.

Steps 2–4 run asynchronously while the presentation moves through pending → processing → completed. Once complete, it's ready to attach to any agent.

Parsing has two jobs: split the document and normalize what it finds.

PDFs are page-split: Each page becomes one slide, which maps naturally to how decks are designed: one idea per page.

PowerPoints are slide-indexed: The parser walks the PPTX structure slide by slide, capturing text frames, titles, and layout information.

Normalization then produces a single internal representation regardless of source format. Every slide becomes the same shape: a title, body content, and metadata about what the slide contains. This matters downstream - the extraction and indexing stages never need to know whether a slide came from PDF or PowerPoint.

Raw text alone is a poor signal. "Slide 12: Q3" tells a retrieval engine almost nothing. The extraction engine layers two kinds of understanding:

Deterministic extractors handle structure. They parse layout to find titles, order text the way a human reads it, and weight elements - slide titles carry more signal than footer text. These passes are fast, cheap, and deterministic: the same slide always produces the same result.

A language model pass handles meaning. It reads the structured output and enriches each slide with topic labels, summaries, and the kinds of questions the slide can answer. This is what turns "Q3 Pricing Update" from a title string into something the engine can match against "how much does the enterprise tier cost?"

The hybrid split is deliberate. Heuristics guarantee speed and consistency; the LLM pass adds depth only where it adds value. A text-heavy slide and a mostly-visual diagram both end up retrievable - not just the ones with clean text.

Extraction produces understanding. The knowledge base engine makes it usable at conversational speed, and it's built in-house for two reasons: speed and reliability.

Speed: Slide retrieval happens mid-conversation - the agent searches before it answers, so a slow index means a slow answer. The engine maintains pre-computed indexes per deck, caches aggressively, and retrieves in sub-second time so presentation lookup never becomes the bottleneck of a live session.

Reliability: Slide retrieval shares the same foundation as Knowledge Base retrieval: one consistent, battle-tested engine instead of a glue layer of third-party components. Retrieval quality is uniform across decks, agents, and sessions, and the engine degrades gracefully - when no slide is a strong match, the agent simply answers from its system prompt and knowledge base. No broken slide flashes on screen.

The engine also handles deck metadata. The name and description you give a presentation aren't labels; they're routing signals the agent reads to decide which deck to search before deciding which slide to show.

The pipeline is built to understand real-world decks, but a few habits measurably improve retrieval:

- Split large decks by topic Five focused 20-slide decks retrieve better than one 100-slide master.

- Use clear slide titles Titles are heavily weighted in retrieval. "Q3 Pricing Update" beats "Slide 12".

- Prefer PDF when you can PDFs process faster and extract cleaner.

- Write specific names and descriptions They route the agent to the right deck.

- Test like a user Ask 5–10 real questions in a test session and watch which slides surface.

Getting a deck in front of your users takes three steps: create the presentation, attach it to an agent, and test it in a live session. You can do this in the TruGen Studio or through the API.

Every presentation starts with a name and a description. These aren't just labels. The agent reads them to decide whether a deck is relevant to a user's question, so a vague name or an empty description means the agent won't pick the presentation even when it should.

In the Studio:

1. Go to app.trugen.ai and click Presentations in the left panel under Configure.
2. Click Create New, then give the presentation a clear Name and a specific Description.
3. Upload your deck as a .pdf or .pptx file, up to 100 MB.
4. Click Save & Create.

Your deck is then queued for indexing, and its status moves through pending → processing → completed. This is the parse, extract, and index pipeline described above, running in the background.

Via the API:

Send the name, description, and file in a single multipart/form-data request:

curl --location 'https://api.trugen.ai/v1/ext/presentation' \
  --header 'x-api-key: YOUR_API_KEY' \
  --form 'name="Q3 Sales Deck"' \
  --form 'description="Quarterly sales presentation for 2025. Use when asked about sales metrics, product growth, revenue targets, or Q3 results."' \
  --form 'input=@/path/to/presentation.pdf'

The response includes the presentation's id. Save it, because you'll need it to attach the deck to an agent:

{
  "id": "5d7b525d-f7ef-44c5-9e49-422fdfdb9b2c",
  "name": "Q3 Sales Deck",
  "description": "Quarterly sales presentation for 2025. Use when asked about sales metrics, product growth, revenue targets, or Q3 results.",
  "status": "pending"
}

The API also lets you manage presentations over time: list them with GET /v1/ext/presentation, fetch one with GET /v1/ext/presentation/{id}, update details with PATCH /v1/ext/presentation/{id}, and remove one with DELETE /v1/ext/presentation/{id}.

Writing names and descriptions that route well

Since the name and description decide whether your deck gets picked, it's worth a moment to write them well. Compare these:

Name: Sales-Deck-Q3
Description: Use this whenever the user asks about sales performance, Q3 targets, revenue breakdown, or sales strategies.

Name: Deck1
Description: Slides

The first tells the agent exactly when to reach for this deck. The second gives it no signal at all.

Step 2: Attach it to an agent

A presentation sits idle until it's attached to an agent.

In the Studio:

1. Open the agent in app.trugen.ai.
2. In the agent's configuration tabs, open Visual Presentations.
3. Select the presentation from your library.
4. Save the agent. The next session picks up the new configuration automatically.

Via the API:

Include the presentation's id in the agent's visual_presentations array when creating or updating the agent:

{
  "agent_name": "Sales Agent",
  "agent_system_prompt": "You present products and answer sales questions.",
  "visual_presentations": [
    { "id": "5d7b525d-f7ef-44c5-9e49-422fdfdb9b2c" }
  ]
}

Presentations and Knowledge Base work together

Presentations don't replace your Knowledge Base; they complement it. Use a Knowledge Base for text answers grounded in documents, like FAQs, policies, and product docs. Use Visual Presentations when the answer needs to show something, like pitch decks, tutorials, and product screenshots. Most agents benefit from both.

Ready to turn your agent into a presenter? Head to app.trugen.ai to upload your first deck, or read the Presentations documentation for the full reference.