Picture a financial services team.

Weekly client decks
  ← read quarterly reports, compliance documents, market analyses
  ← pull key figures from hundreds of pages
  ← structure slides, write copy, generate visuals
  ← repeat, every week

An October 14 AWS post automates this with an agent system. The numbers come first.

Input: a 90-page PDF (Amazon's 2024 Annual Report)
Output: a six-slide deck (title, bullets, image+text, image-only, takeaways)
Time: 70–90 seconds end-to-end (retrieval → generation → images → assembly)
Cost: about $0.04 in model invocation cost (image generation dominates)
Knowledge base ingestion: under 2 minutes for a 1.3 MB PDF

All from internal testing, of course — not infrastructure cost and not a general promise of speed. The real lesson is the structure, and specifically how that structure handles grounding.

The shape: one supervisor, two tools

[User request] → API Gateway → Chat API (.NET 8 on Lambda)
                    │
                    ▼
        Supervisor Agent (AgentCore runtime, Strands)
                    │
        ┌───────────┴───────────┐
        ▼                       ▼
  generate_pptx            generate_summary
  (PPTX Generator Lambda)  (Summary Generator Lambda)
        │                       │
        ▼                       ▼
  Knowledge base retrieval (RAG) → Claude Sonnet 4.6, grounded generation
        │
        ├─ Titan Text Embeddings v2
        ├─ OpenSearch Serverless vector search
        ├─ Stability AI image generation (two slide images)
        └─ Bedrock Guardrails (input, output, PII)

The pieces:

- RAG pipeline: S3 docs → chunk and parse (special handling for tables, charts,
  images) → Titan Text Embeddings v2 → OpenSearch Serverless storage
  → similarity search at query time → context to Claude Sonnet 4.6
- Images: Stability AI Stable Image Inpaint for slide visuals
- Guardrails: input (injection, inappropriate content), output (policy),
  and PII masking
- Delivery: PPTX stored in S3, presigned download URLs valid for 5 minutes
- Formatting: branded title slides, bullets, speaker notes included

This is not one magic prompt. Retrieval, outline structure, copy generation, image generation, and file assembly are separate tools under a supervisor. The stated design goal: ground generated content in the enterprise knowledge base to reduce hallucination.

The practical snag: 90 seconds means async

Here is a telling technical detail. API Gateway's default integration timeout is 29 seconds. This job takes 70–90.

The pattern
  - Raise the API Gateway timeout to 300 seconds (documented setting)
  - And still don't make users hold a synchronous call
    → stream or poll for the final result

The lesson
  Once agent work outlives a web request budget,
  UX shifts from "request-response" to "job-notification"

This is a common miss when bolting on agent automation: the pipeline works, but users end up refreshing every thirty seconds. Long-running work requires designing the product experience, not just the backend.

Harder than speed: numbers that match the source

The real risk in deck automation is not generation speed.

Easy: plausible sentences, clean structure
Dangerous: numbers that differ from the source, unsourced claims, overstated summaries

If one revenue figure from a quarterly report is wrong on one slide, the deck's credibility collapses. So the part worth copying is not the generation half — it is the grounding half.

- Track citations back to source documents in summaries
- Add a comparison step for slides with numbers (source vs generated)
- If documents carry PII, Guardrails masking is not optional
- Keep templates and branding fixed; generate only the content

The AWS sample goes a step further: Guardrails re-check generated content against policy before delivery. "Models generate, the pipeline verifies" — the same principle as the 9-stage pipeline case.

CodeBridge mini lab: a deck automation checklist

If you plan to bring this in-house:

[ ] Can every claim on a slide be traced back to the source?
[ ] Is there a verification step comparing numbers, dates, and names to the source?
[ ] Is PII prevented from landing on slides?
[ ] Does the 70–90 second job have an async UX (progress, notification)?
[ ] Is model cost (~$0.04) measured separately from infrastructure cost?
[ ] Do brand templates survive automated generation?
[ ] Have infrastructure constraints (like OpenSearch data plane access) been checked?

That last item is the post's hidden technical point: because Bedrock Knowledge Bases access OpenSearch Serverless from AWS-managed infrastructure, the collection's data plane must remain publicly accessible, protected instead by IAM policies and VPC restrictions. A tidy example of where the convenience-versus-security trade-off actually lands.

Conclusion: the value of 90 seconds is the evidence, not the slides

Deck automation's edge comes not from generation speed,
but from a structure that can answer "where did this number come from?"

Ninety seconds and four cents impress — until a figure drifts from the source. Retrieve for grounding, generate, then verify against policy: a three-stage pipeline. Start with one document (an annual report, a quarterly filing), generate six slides, and reconcile every number against the original. The moment reconciliation passes, automation can begin.

Further reading

References

Go deeper with a course

Turning documents into grounded writing, images, and finished output sits squarely in generative content work. Practice writing, images, and video as one flow — and decide what to generate versus what to verify.