You know the scenario. A 15-slide deck is due for tomorrow's stakeholder meeting. You open PowerPoint, stare at a blank slide, and watch your afternoon evaporate. The content itself is straightforward—you know exactly what you want to say—but the mechanical work of creating slides, arranging text boxes, and picking layouts eats hours you simply don't have.
AI language models can write the content, but getting that content into a properly formatted presentation file has remained a separate challenge. Most existing solutions either generate static images or lock you into proprietary cloud platforms.
Binaryify/open-kimi-ppt-skill takes a different approach. This open-source project gives AI agents the ability to generate two distinct presentation formats—PPTD and PPTX—and pairs that capability with a local browser editor. You can tweak the results without uploading anything to a third-party server.
This article walks through what this skill does, how it works under the hood, how to set it up, and where its limitations sit.
Before diving into installation, let's clarify the key terms.
PPTD is the native file format for Kimi Slides, Moonshot AI's presentation tool. If you use Kimi's ecosystem, PPTD files open directly in their cloud editor with full fidelity—layouts, themes, and embedded objects all render as intended.
The catch: PPTD is proprietary. There's no official public specification, and tools outside the Kimi ecosystem don't natively read it. That makes programmatic generation tricky, which is exactly why this project had to reverse-engineer the format.
PPTX is the open, standardized presentation format used by Microsoft PowerPoint and supported by LibreOffice Impress, Google Slides, and most other presentation software. It's a ZIP archive containing XML files that describe slide content, layouts, and styling.
PPTX is the safe bet for sharing presentations widely. Almost anyone can open it.
An AI agent is a program that uses a large language model (LLM) to reason about tasks and take actions beyond just generating text. Agents like AutoGPT or MetaGPT can break down complex goals into steps, call external tools, and execute multi-stage workflows.
A skill is a modular capability you attach to an agent. Think of it as a plugin: it extends what the agent can do. This skill teaches your agent how to produce presentation files—both PPTD and PPTX—from natural language instructions.
Most presentation tools are cloud-first. You upload your file, edit in a web interface, and your data sits on someone else's server. This project flips that model. The editor runs entirely on your machine, served by a local Node.js server, and opens in your browser. Your files never leave your computer.
Key Takeaway: This skill isn't a standalone app. It's a bridge that connects AI agents to presentation file generation, with a local editor for post-generation tweaks.
The architecture follows a straightforward pipeline:
AI Agent (your LLM workflow)
↓
Skill API (Node.js server)
↓
File Generation (PPTD / PPTX)
↓
Local Browser Editor (optional post-editing)
The AI agent sends structured requests to the skill's API. The skill processes those requests, generates the presentation file, and returns a success response with the file path. If you want to edit the result, you open the local editor and make changes visually.
The entire skill is built on Node.js. This choice makes sense for three reasons:
node command starts both the API server and the editor.The editor itself uses standard HTML, CSS, and JavaScript—no exotic frameworks or build steps required.
For PPTX output, the skill uses pptxgenjs, a well-established open-source library. It provides a programmatic API for creating slides, adding text boxes, shapes, images, and charts, then serializing everything into a valid PPTX file.
The skill maps the agent's content instructions to pptxgenjs calls. For example, if the agent says "create a title slide with the text 'Q3 Financial Review'," the skill translates that into a slide with a centered title text box.
PPTD generation is the harder problem. Since there's no public spec, the project maintainers analyzed existing PPTD files—examining their internal XML structure, identifying how content blocks are organized, and building a custom parser that can both read and write the format.
The implications are significant:
Key Takeaway: PPTD support is a reverse-engineering effort, not an official integration. It works for common slide structures but has inherent limitations.
The editor provides a slide-by-slide view of your generated presentation. You can:
Technically, it's a single-page web app served by the Node.js server. It reads the generated file, parses the content, and renders a visual representation. When you save, it serializes your changes back to the file format.
The editor deliberately avoids complex features. You won't find animation timelines or 3D transitions. The focus is on content editing—fixing typos, adjusting layouts, adding a missing point.
Here's the typical flow:
The entire process, from prompt to finished file, typically takes under a minute for a standard deck.
Before you start, you need:
git clone https://github.com/Binaryify/open-kimi-ppt-skill.git
cd open-kimi-ppt-skill
npm install
That's it for dependencies. The project has no external database or service requirements.
Create a .env file in the project root:
# Your AI agent's API key (if using a hosted LLM)
OPENAI_API_KEY=your_key_here
# Output directory for generated presentations
OUTPUT_DIR=./output
# Port for the local editor server
EDITOR_PORT=3000
Adjust the values to match your setup. If you're using a local LLM (like Llama 3 via Ollama), you may not need an API key at all.
npm run editor
This starts the server and opens your default browser to http://localhost:3000. You can now load generated files or create new ones manually.
AutoGPT: Add the skill as a plugin by placing it in the plugins directory and configuring the plugin manifest. The skill exposes a generate_presentation action that the agent can call.
MetaGPT: Define the skill as a tool in your agent's tool registry, specifying the input schema (slide data, format, output path).
Custom workflows: You can call the skill's HTTP API directly. Post slide data as JSON to /api/generate, and the skill responds with the file path.
| Problem | Likely Fix |
|---|---|
npm install fails |
Update Node.js to version 16+ and retry |
| Editor doesn't open | Check that port 3000 isn't in use; change EDITOR_PORT in .env |
| Generated PPTX won't open in PowerPoint | Ensure your agent sends valid slide data; check output file with a text editor |
| PPTD files error in Kimi Slides | Some PPTD features aren't supported; try simpler layouts |
Raw AI-generated slides look generic. For professional use—client pitches, executive reviews, investor updates—you need branding consistency: your logo, your color palette, your font choices.
The skill supports customization at two levels: configuration files and prompt instructions.
In the project's config directory, you'll find template definitions. Each template specifies:
You can edit these directly or create new template files.
The more flexible approach is prompt-based. When you instruct your AI agent, include styling directives:
"Create a 12-slide investor deck. Use dark navy background (#1a1a2e), white text, accent color gold (#e6b31e). Title slides should have centered text; content slides use left-aligned bullets."
The agent translates these instructions into the slide data it sends to the skill, which applies the styling during generation.
For recurring use cases—weekly status reports, monthly KPI reviews—build a template once and reuse it. Define the layout structure, placeholder text, and styling in a template file, then have your agent fill in the content each time.
Key Takeaway: The skill's customization is primarily content-driven. You define the design language, and the agent applies it consistently across all generated slides.
A marketing team uses an agent to generate a 15-slide product pitch deck. The agent pulls key features from a product spec, structures them into benefit-oriented slides, and generates a PPTX file. The team opens it in the local editor, tweaks the messaging, and exports the final version for email distribution.
Time saved: Roughly 2-3 hours per deck.
A developer integrates the skill into an AutoGPT workflow. Every Friday, the agent collects git commit data, summarizes completed work, and generates a PPTD status report for the Kimi Slides workspace. The developer reviews it in the local editor, adds a few notes, and shares it with the team.
Time saved: The developer estimates 2 hours per week.
An educator uses the skill to generate lesson plan presentations. The agent creates slides with learning objectives, activity descriptions, and assessment questions. The educator uses the local editor to add custom images and reorder slides—without needing PowerPoint installed on their school-provided laptop.
A startup generates its investor pitch deck in both PPTD and PPTX formats simultaneously. This ensures compatibility with Kimi Slides users (via PPTD) and Microsoft Office users (via PPTX). The dual-format approach eliminates the "can you send it as a PowerPoint?" problem.
A freelance consultant works with sensitive client data. They run a local LLM (Llama 3 via Ollama) and use this skill entirely offline. The agent generates client proposals as PPTX files, and the local editor handles any revisions. No data ever touches a third-party server.
The PPTD format implementation is based on analysis, not official documentation. If Moonshot AI updates their format, files generated by this skill may fail to open or render incorrectly in Kimi Slides. Always test generated PPTD files in your target environment before distribution.
The local editor handles content editing well but doesn't support animation timelines, morph transitions, or embedded media playback. If your presentation requires heavy visual effects, you'll need to add those in a full-featured tool after generation.
The editor runs locally on your machine. There's no multi-user editing, no comments, no change tracking. If your team needs collaborative editing, you'll need to export to a cloud platform (Google Slides, PowerPoint Online) after generation.
The skill faithfully converts whatever content your agent provides. If the LLM produces weak, repetitive, or inaccurate content, your presentation will reflect that. The skill doesn't fact-check or enforce quality standards.
The project is MIT licensed, which allows free commercial and personal use. However, the PPTD reverse-engineering aspect exists in a legal gray area. Using the skill to generate PPTD files for personal or business purposes is likely fine, but distributing a product that relies on the reverse-engineered format could raise concerns if Moonshot AI pursues enforcement.
Key Takeaway: This is a practical tool with real constraints. Understand what it can and can't do before building critical workflows around it.
As of early 2025, the repository has over 1,000 stars and a healthy fork count, indicating solid community interest. More than 20 developers have contributed code, and the project has seen 15+ releases since its late 2024 launch.
The maintainer (Binaryify) responds to issues and merges pull requests regularly. Community contributions have added support for additional slide layouts, improved error handling, and documentation refinements.
If you want to help:
Tools like Canva, Gamma, and Tome generate presentations in the cloud. They offer polished templates and collaboration features, but your content passes through their servers. The local editor in this project keeps everything on your machine—a meaningful difference for privacy-sensitive work.
Gamma and Tome generate complete decks from prompts, but they're closed platforms with their own file formats and limited export options. This skill produces standard PPTX files that work with existing office tools, plus PPTD for Kimi users.
Manual creation gives you complete control but consumes your time. The skill handles the mechanical generation so you can focus on content quality and design refinement.
Choose this skill when:
Skip it if you need heavy visual effects, real-time collaboration, or guaranteed compatibility with future Kimi Slides updates.
Binaryify/open-kimi-ppt-skill addresses a real pain point: getting AI-generated content into usable presentation files without fighting format limitations or sacrificing privacy.
The project's two-format approach is practical. PPTX covers the universal need for shareable presentations. PPTD covers the niche (but growing) Kimi Slides ecosystem. The local editor fills the gap between generation and final polish, letting you make quick adjustments without opening a heavy office suite.
The reverse-engineered PPTD support is the project's most ambitious feature and its biggest risk. It works for common use cases today, but it's not guaranteed to survive future format changes. For critical presentations, always verify generated PPTD files in Kimi Slides before distribution.
The broader significance is what this project represents: the shift from AI as a text generator to AI as a task-completion tool. By giving agents the ability to produce real, editable files in multiple formats, projects like this move us closer to genuinely useful automation.
If you're already using AI agents and tired of manual slide creation, this skill is worth a try. The setup takes about ten minutes, and the payoff is reclaiming hours of mechanical work each week.
It extends AI agents with the ability to generate editable presentation files (PPTD and PPTX) from natural language prompts, plus provides a local browser editor for post-generation adjustments.
No. The skill runs independently on Node.js. You only need PowerPoint if you want to open PPTX files in that application, or Kimi Slides if you want to open PPTD files there. The local editor handles basic editing without either.
Clone the repository, run npm install, configure your .env file with API keys and output paths, then integrate the skill with your agent framework (AutoGPT, MetaGPT, or custom) by registering it as a tool. The README includes specific integration examples.
Yes. You can define templates in the config directory (colors, fonts, layouts) or include styling instructions in your agent prompt. The agent passes these design directives to the skill during generation.
No. PPTD is proprietary to Kimi Slides. This skill generates PPTD files that open in Kimi Slides, but other presentation tools won't recognize the format. Use PPTX for broader compatibility.
No. The editor runs locally and supports a single user at a time. For collaborative editing, export to a cloud platform after generation.
You need Node.js (version 16+) and npm. The skill itself is written in JavaScript. Your AI agent can be in any language, as long as it can make HTTP calls to the skill's API.
The skill itself is free and MIT-licensed. You'll pay for any LLM API usage if you use hosted models. If you run a local LLM, there's no cost beyond your hardware.
The skill exposes a generic HTTP API, so any agent that can make HTTP requests can use it. Pre-built integrations exist for AutoGPT and MetaGPT, but custom workflows work equally well.
The PPTD format is reverse-engineered and may break with future Kimi Slides updates. The editor lacks support for animations, complex transitions, and real-time collaboration. Output quality depends heavily on your LLM's content generation ability.
Ready to automate your slide creation? Visit the GitHub repository, star the project, and start generating editable presentations with your AI agent today!