IBM Research unveils Palette to build custom branded slide decks

IBM Research has introduced Palette, a specialized approach designed to train small, open-weight language models to generate professional slide decks that adhere to specific brand design languages. This development addresses a common limitation in frontier AI models, which often default to a generic "AI-generated" aesthetic regardless of user prompting.

Why are slide decks difficult for small models?

According to IBM Research, generating a presentation is significantly more complex than simple text generation because it requires the model to master three distinct challenges simultaneously. First, the model must perform spatial reasoning without visual feedback; it writes code to place elements at specific coordinates, often failing to realize that a title is too large for its designated space until the code is rendered.

Second, the model must balance editorial judgment with geometric precision. It has to decide both what information is important enough to include and how to physically arrange that information—such as choosing between a chart or a table—while maintaining visual consistency across many slides. Finally, there is a lack of high-quality training data that captures not just the final slides, but the underlying design rationale and the code used to construct them.

How does the Palette architecture work?

To overcome these hurdles, Palette mimics a human workflow by splitting the task into two distinct roles managed by a single LoRA adapter. The first role is the "designer," which processes a plan to create a structured JSON brief. This brief includes the color palette, typography, slide layout, content, and a design rationale. The second role is the "coder," which takes the designer's brief and writes the JavaScript code (using pptxgenjs) required to draw each individual slide.

By separating editorial decisions from geometric execution, the system becomes more reliable. Because the coder works on one slide at a time based on a fixed brief, the generation process can run in parallel, making the coding stage approximately six to seven times faster than traditional methods. This modularity also allows humans or other agents to edit a single slide's layout without needing to regenerate the entire presentation.

How is the model trained using synthetic data?

Since public datasets of design reasoning are scarce, the researchers used a large "teacher" model to synthesize a dataset of approximately 1,000 decks containing 10,000 slides. A key innovation in this training process is the inclusion of counterfactual reasoning. Instead of just providing the final design choice, the training data explains why alternative choices were rejected.

For instance, a designer might note that a bar chart was chosen over a table specifically to highlight a trend rather than exact figures. Similarly, a coder might explain that a font size was reduced to prevent text from overlapping a chart. This teaches the model the underlying rules of design rather than just pattern matching. To ensure quality, every synthesized deck is rendered and checked for errors; any broken slides are repaired, and the fixes are fed back into the training loop as new examples.

Can users control the design through plain English?

Yes. Palette allows for granular control through "directives," which are short instructions wrapped in double brackets, such as [[make this a timeline]] or [[highlight the headline number]]. These directives are integrated into the designer's brief, which the coder then follows during the rendering stage.

The model's ability to follow these commands stems from its training on a diverse recipe of 12 directive categories, including layout, tone, audience, and emphasis. This enables users to steer the visual output—for example, changing a standard bulleted list into a timeline—using natural language without needing to manually adjust code or complex prompts.

How does the system ensure the final output is error-free?

To prevent common issues like overlapping text or invisible colors, Palette utilizes a "check-and-repair harness." Once the model generates the code, the harness applies simple rules to fix malformed data and then renders the slide to perform geometric measurements. If the checker detects that text is clipped or elements are stacked incorrectly, it sends the slide to a separate editor model to rewrite the code.

Crucially, the harness only keeps a rewrite if the checker confirms the new version is an improvement, ensuring the system never makes a slide worse than the original. In evaluations using the PresentBench benchmark, this harness added an average of 3.5 points to the quality scores of generated decks.

How does Palette compare to other AI systems?

In testing on the PresentBench benchmark, which evaluates fundamentals, visual design, completeness, correctness, and fidelity, Palette demonstrated strong performance for an open-weight model. It ranked first in the Economics and Education domains, where structured content and numerical accuracy are paramount. While it placed third in the "Talk" domain—where narrative flow is more critical—it secured second place in the overall three-domain mean, performing closely behind frontier systems like NotebookLM.

For researchers and professionals looking to analyze complex documents or papers that might serve as the basis for such presentations, the principles of structured reasoning and data extraction explored by IBM are highly relevant. You can explore how to query and synthesize information from dense technical documents using Grafy Reader.

Frequently asked questions

Does Palette require a large model to function?

No, Palette is designed to work with a relatively small 20B parameter model. By using a LoRA adapter and a structured two-role workflow (designer and coder), the researchers proved that a smaller, open-weight model can achieve high-quality results that compete with much larger frontier models in specific tasks like slide generation.

Can Palette follow specific brand guidelines?

Yes, Palette is specifically built to learn and implement a user's unique design language. Unlike frontier models that tend to drift toward a generic "AI style," Palette can be trained on a company's specific palettes, typography, and layouts, allowing it to produce decks that look like they were created by an in-house design team.

How does the system handle mistakes in slide layout?

The system uses a check-and-repair harness to identify and fix mistakes. This harness renders the slide and checks for geometric errors like overlapping text or overflowing shapes. If an error is found, a separate editor model attempts to rewrite the code, and the change is only applied if the harness confirms the slide has actually improved.

---

Source: Hugging Face Blog — Palette: teaching a small model to build decks in your design language