1. Introduction
Large Language Models have enabled powerful automation systems capable of performing complex tasks such as document generation, research summarization, and structured content creation. However, monolithic prompt-based approaches often lack reliability, modularity, and maintainability when deployed in production environments.
To address these challenges, this project introduces the Agentic AI PowerPoint Builder, a production-ready multi-agent system that autonomously researches, plans, writes, and assembles professional PowerPoint presentations from a simple user prompt.
The system uses a five-agent architecture coordinated through a central orchestration layer. Each agent specializes in a single task—planning slides, gathering research, writing content, generating images, and building the final presentation.
This project demonstrates how agentic architectures can be productionized through structured error handling, safety guardrails, modular design, automated testing, and deployment-ready configuration.
2. Live Deployment
The production system has been deployed using Streamlit.
Live Application:
https://agentic-ppt-builder-ngc9r4gbrguxnjq7tw7kqg.streamlit.app/
Source Code:
https://github.com/yash-dharamshi/agentic-ppt-builder
3. System Architecture
The system is implemented as a five-agent pipeline orchestrated through a central controller.
Architecture Diagram:
Each agent performs a specialized task:
| Agent | Responsibility |
|---|---|
| PlannerAgent | Generates a structured slide outline |
| ResearchAgent | Retrieves factual content using web search |
| WriterAgent | Converts research into structured slide bullet points |
| ImageAgent | Generates or retrieves images for each slide |
| BuilderAgent | Compiles slides into a final PowerPoint presentation |
Agents communicate via a shared state object (AgentState), enabling modularity and loose coupling between components.
4.User Experience Design
The system is designed with a simple and intuitive interface using Streamlit. Users can generate presentations by providing a topic and optionally customizing parameters such as slide count, font, and content depth.
Application Interface
-
Input Interface :
-
Presentation Generation :
-
Final Output & Download :
5. Production Engineering Improvements
Following the ReadyTensor review feedback, the system was enhanced to improve reliability, safety, and maintainability.
5.1 Safety Guardrails
A prompt safety validation layer was introduced to prevent unsafe or harmful requests.
The check_prompt_safety() function detects patterns related to:
- illegal activities
- violent content
- self-harm
- terrorism
The validation runs before pipeline execution, ensuring the system does not generate unsafe content.
If unsafe input is detected, the request is rejected with a user-friendly error message.
This guardrail ensures responsible deployment of the AI system.
5.2 Improved Error Handling
External services such as LLM APIs and image generation tools may fail due to network issues or rate limits.
To ensure reliability, the system implements:
- structured exception handling
- retry mechanisms
- graceful fallbacks
Each agent includes try/except blocks around external calls.
Example protections include:
- LLM invocation failures
- image generation API failures
- file generation errors
- pipeline execution errors
Errors are captured through the centralized error handling utilities and logged without crashing the system.
5.3 Logging and Observability
The system includes a structured logging framework that records:
- agent execution steps
- pipeline execution time
- errors and fallback behavior
- external API calls
Logs enable easier debugging, monitoring, and system diagnostics during production use.
5.4 Deployment Configuration
To support reliable deployment, the project includes configuration files such as:
.streamlit/config.toml.env.example
These files define server configuration, environment variables, and API key placeholders.
The Streamlit configuration enables headless deployment with CORS disabled and consistent server settings.
6. Alternative Solution Comparison
Several approaches exist for automating presentation generation.
| Approach | Description | Limitations |
|---|---|---|
| Manual PowerPoint creation | Human authors slides manually | Time-consuming and repetitive |
| Single LLM prompt | Entire presentation generated from one prompt | Often produces inconsistent or poorly structured slides |
| Template-based tools | Predefined slide templates populated with text | Limited customization and research capability |
| Agentic PPT Builder (this project) | Multi-agent pipeline with specialized tasks | Slightly more complex architecture but significantly higher quality output |
The multi-agent design enables better control over each stage of the content generation process.
7. Performance Metrics
To evaluate system reliability and efficiency, several performance indicators were measured.
| Metric | Value |
|---|---|
| Agents used | 5 |
| Automated tests | 105 |
| Average slide generation time | ~10–20 seconds |
| Supported slide range | 1–20 slides |
| Test success rate | 100% (105/105 passing tests) |
| Deployment platform | Streamlit Cloud |
The addition of safety validation increased the total automated tests from 88 to 105, ensuring robust coverage of both functional and safety scenarios.
8. User Experience Design
The system interface was designed with simplicity and usability in mind.
Key design decisions include:
- Minimal input interface – users only need to provide a topic
- Optional customization controls – slide count, font style, and content depth
- Readable formatting – generated slides use standard presentation fonts
- Immediate feedback – validation errors appear directly in the UI
- Clear download workflow – generated presentations can be downloaded instantly
The Streamlit interface reduces cognitive load while maintaining flexibility for more advanced configurations.
9. Testing Strategy
The project includes a comprehensive automated test suite implemented with pytest.
Tests cover:
| Test Category | Description |
|---|---|
| Agent Unit Tests | Validate individual agent behavior |
| Tool Tests | Validate web search, image generation, and PPT creation tools |
| Error Handling Tests | Validate fallback and retry behavior |
| Integration Tests | Validate full multi-agent pipeline execution |
| Safety Tests | Validate prompt safety guardrails |
Total tests:
105 tests passed in 6.46 seconds
The safety guardrail implementation introduced 17 additional tests, verifying correct rejection of unsafe prompts.
10. Installation and Usage
Installation
git clone https://github.com/dharamshiyash/agentic-ppt-builder.git cd agentic-ppt-builder python -m venv venv source venv/bin/activate pip install -r requirements.txt
Configure environment variables in .env.
Running the Application
Streamlit interface:
streamlit run app.py
Command-line usage:
python main.py --topic "Artificial Intelligence in Healthcare"
The generated presentation will be saved in the outputs/ directory.
11. Licensing and Usage Rights
This project is released under the MIT License, which allows users to:
- use the software for personal or commercial purposes
- modify and extend the code
- distribute copies of the software
The only requirement is proper attribution to the original author.
The license promotes open collaboration and encourages community contributions.
12. Limitations
Despite the robustness of the system, several limitations remain.
-
The quality of generated slides depends on the accuracy of the LLM responses and web search results.
-
Image generation relies on external APIs, which may introduce latency or occasional failures.
-
The current pipeline executes sequentially, which may increase generation time for large presentations.
-
Domain-specific presentations (e.g., medical or legal topics) may require more specialized knowledge sources.
Future improvements could address these limitations through parallel agent execution, domain-specific retrieval pipelines, and improved caching strategies.
13. Future Work
Several enhancements can further improve the system:
-
Parallel agent execution to reduce overall pipeline latency
-
Retrieval-augmented generation (RAG) using curated knowledge bases
-
Asynchronous task queues for scalable background processing
-
Improved observability dashboards for monitoring agent performance
-
Containerized deployment using Docker and CI/CD pipelines
These improvements would allow the system to scale to enterprise-level production workloads.
14. Security and Responsible AI Considerations
To ensure safe deployment of the system, several responsible AI measures were implemented.
-
Prompt safety guardrails detect unsafe requests related to violence, illegal activities, and harmful content.
-
Input validation and sanitization prevent malformed or malicious inputs.
-
Graceful failure handling ensures that external API errors do not crash the system.
-
Controlled output generation limits slide counts and content depth to prevent misuse.
These measures ensure that the system operates responsibly while maintaining reliability in production environments.
15. Conclusion
The Agentic AI PowerPoint Builder demonstrates how a complex multi-agent AI workflow can be transformed into a production-ready system.
Key contributions include:
- modular multi-agent architecture
- robust safety guardrails
- improved error handling
- deployment-ready configuration
- extensive automated testing
- user-friendly interface
The project highlights how agentic systems can be engineered with reliability, maintainability, and responsible AI practices in mind.