Tool Reviews

Palette teaches a small model to build decks in your design language.

Palette trains a small open model for design-language decks, splits editorial and coding roles, adds a repair harness, and tops PresentBench domains.

Palette teaches a small model to build decks in your design language.

Key Takeaways

  • Palette fine-tunes a 20B open-weight model to create IBM Design Language slide decks by splitting work into a designer that writes structured JSON briefs and a coder that converts each brief into slide code.
  • The method targets small-model weaknesses in deck creation: unseen layout geometry, simultaneous editorial and design decisions, and limited public training data for slide-building.
  • Training uses generated decks with counterfactual design reasoning and supports precise user control through directives such as [[make this a timeline]].
  • A check-and-repair harness renders each slide, detects overlaps, clipping, or malformed formatting, and keeps only verified improvements, adding 3.5 points on average across 131 PresentBench decks.
  • The approach is relevant for users who want template-like decks, faster parallel coding, and confidential content kept on their own infrastructure.

Meta description: Palette fine-tunes a 20B open-weight model to build slide decks with IBM Design Language, PresentBench scores and a check-and-repair harness tool.

Palette teaches a small model to build decks in your design language.

Tags: AI, Open Models, Presentation Design, Low-Rank Adaptation, PresentBench

Featured image: Abstract friendly illustration of a 20B open model arranging slides with color swatches, charts and repair arrows, no people, logos or visible text.

In a post, the Palette project introduced a fine-tuned 20B open-weight model that builds presentation decks by separating the work into a designer and a coder. Trained on the IBM Design Language, it ranks first on two of three domains in PresentBench. Across 131 decks, it gains 3.5 points on average when a check-and-repair harness is used. The result matters for readers who want template-like decks while keeping confidential content on their own infrastructure.

Why small models struggle with slide decks

A slide deck looks simple, but it asks a model to do three things small models are weak at.

First, it must lay out a slide without seeing it. The model does not draw pixels; it writes code that gives every element an x position, y position, width and font size. A title with 75 characters at 56pt may need two lines or may spill into another object. Small models often miss that arithmetic until the code renders, producing overlapping shapes and clipped text.

Second, a deck requires editorial and geometric decisions at once. The model must choose what each slide says, what to cut and whether a chart or table is clearer, while placing the content precisely. Across 10 to 20 slides, it also has to keep the palette, type and layout consistent.

Third, there is little public data showing how decks are made. Finished decks are common, but the rationale behind design choices and the code that produced them are not. That is why a small open-weight model can look capable in chat yet create broken decks.

How Palette splits the work and creates data

Palette imitates the way people build decks: decide the story first, then build each slide. It uses one low-rank adaptation (LoRA) adapter for two roles.

The designer reads the plan and writes a brief in JavaScript Object Notation (JSON), a structured data format. The brief records the palette, the type system and, for each slide, the layout, exact content and a short design rationale. The coder takes one slide's spec and writes pptxgenjs JavaScript to draw it, preceded by its reasoning.

This separates the decisions. The designer handles editorial judgment; the coder handles geometry. The brief is readable and editable, so a person or agent can change one slide's layout without regenerating the deck. Because each slide's context is fixed before code is written, coder calls run in parallel, one per slide, making the coding stage about 6 to 7 times faster.

The adapter was trained with LoRA rather than full fine-tuning, so it teaches a format and a skill without disturbing the base model. Coder examples are about 5 times longer than designer examples, so the team oversampled designer examples 5 times to keep the designer role from being undertrained.

To get training data, the project used a large open teacher and recipes that set genre, length, layouts and user directives. Plans range from tidy outlines to raw content dumps, teaching the model to cut and condense. The team generated about 1000 decks covering roughly 10,000 slides.

Each example includes counterfactual reasoning: it names an alternative and explains why it was rejected. A designer note might prefer a bar chart for four-quarter revenue because the trend matters more than exact figures. A coder note might lower a 62-character title from 44pt to 36pt to avoid wrapping into a chart.

Faithfulness was the hardest problem. If a brief asks for a six-by-five table but provides only three bullets, the coder may invent the rest. Prompt rules did not fix it. Reference decks did: when the teacher saw a few reference decks in its prompt, it copied their patterns more reliably than it followed instructions.

Directives and the repair harness

Users often want narrow design control, such as a chart instead of a table, a particular color or a darker cover. Palette accepts directives written directly in the plan and wrapped in double square brackets. The designer builds each directive into the brief, and the coder follows it when drawing the slide. Without a directive, milestones might become a table; with a [[make this a timeline]] directive, the same plan becomes a timeline. The training recipes included directives from 12 categories, each phrased several ways, so the model learns intent rather than a fixed phrase.

Palette teaches a small model to build decks in your design language.

Even a trained model can emit a broken slide, such as a title matching the background color or two boxes stacked on top of each other. Palette sends every deck through a harness before returning it. Simple rules fix known mistakes, including a malformed color code that would otherwise turn every slide black. Each slide is then rendered and measured. A geometry checker flags text that overlaps, gets clipped or runs off the slide. Flagged slides go to a separate editor model that rewrites that slide's code.

A rewrite is kept only if the checker confirms the slide improved; otherwise the original stays. That makes the harness safe to run on every deck. In one example, card titles stacked on top of descriptions were reflowed into a 2×2 grid. Across 131 PresentBench decks, the harness added 3.5 points on average.

What the scores show and what comes next

PresentBench scores decks on fundamentals, visual design, completeness, correctness and fidelity. It provides a source document rather than a plan, so a separate frontier model drafted each plan from the document and Palette built the deck from that plan. Baseline numbers are from the PresentBench paper; the comparison includes NotebookLM, Manus 1.6 and five other systems.

Palette ranked first on Economics and Education, where structured content and numeric accuracy matter. On Talk, where decks are narrative and speech-driven, two closed systems scored higher and Palette placed third. Across the three domains, it placed second, 1.1 points behind NotebookLM, with scores of 59.7 and 60.8, and ahead of the rest of the compared field. As a single 20B open-weight model, that is the main result: the team is not aware of a benchmark that measures whether a deck follows a specific design language, and it sees that as a gap.

Next, the project wants to turn harness signals into rewards for reinforcement learning. The harness already checks whether a slide renders, whether anything overlaps or overflows, and whether facts trace back to the brief. Because the coder works one slide at a time, each slide is a short, independently checkable rollout, a natural fit for group relative policy optimization (GRPO)-style training.

It also wants to improve figure-heavy decks by extracting figures from source documents, for example with Docling, and placing them through the harness. A lighter route to custom templates is under exploration: re-skinning output from one or two existing .pptx files without retraining.

Who should use it / who should skip it

Palette is most useful for teams that need slides in a known design language, especially when content is confidential and must stay on self-hosted infrastructure. It is also a practical pattern for tasks whose output has a structure that can be checked in code: put reasoning in the data, fix examples before adding rules, make repairs safe by default and build the checker first.

Readers who only need a polished deck from a general frontier model may still get a faster result from closed systems, particularly for narrative talk decks. Teams that cannot maintain a local model, a rendering checker or an editing loop may find the setup more effort than benefit. For those who need a model to follow their template, their facts and their design system, Palette shows how a small open-weight model plus a harness can move much closer to that goal.

Comments (0)

  1. No comments yet. Be the first to share what worked for you.

Leave a comment

Comments are reviewed before they appear. Your email address is not published.