Palette Uses a 20B Open Model to Generate Decks in a Consistent Design Language
- Cargo
- Machine Learning
- Shipped
- Shipper
- James Smith
- Readers
- 634
Palette splits deck planning from slide coding and uses a repair harness. It ranks first in two PresentBench domains and second across three.

Palette’s main contribution is a production workflow for slide generation: a 20B open weight model plans and builds decks in a defined design language, while a checking harness catches and repairs layout errors before output reaches the user. On PresentBench, it ranks first in Economics and Education and second across three domains on average. That suggests smaller self-hosted models can produce competitive decks when the task is divided into roles and the output can be checked mechanically.
The project targets two practical limits of frontier models. Their decks can default to a recognizable visual style even when users want a house template, and confidential content may not be suitable for processing outside a team’s own infrastructure. Small open models can run under a team’s control, but often produce malformed slides: text may overflow, elements may overlap, or a title may blend into its background. Palette tests whether targeted fine-tuning and automated review can narrow that quality gap.
Planning and slide construction are separate jobs
A deck requires editorial decisions as well as precise layout work. Someone has to decide how many slides the story needs, what each slide should say, and whether a point belongs in a chart, table or another form. Then each element must be positioned and sized in code. A model writing slide code has to estimate whether text will fit before it can render the result, which is a common source of clipping and collisions.
Palette separates those responsibilities into a designer role and a coder role, served by one LoRA adapter. The designer prepares an editable brief for the deck; the coder turns each slide in that brief into code. Since the coder receives fixed context for each slide, coding calls can run in parallel. The team reports that this makes the coding stage about 6–7 times faster. People or other agents can also edit an individual slide’s brief without asking the system to regenerate the whole deck.
The model was fine-tuned with LoRA, which adds a learned skill and format to a capable base model without replacing its underlying knowledge. It also made experiments less expensive than full fine-tuning. Training examples for the coder were about five times longer than examples for the designer. Mixing them equally left the designer undertrained, so the team oversampled designer examples by a factor of five.
Synthetic examples teach both choices and rationale
There isn’t a public dataset that captures a deck’s plan, design decisions and generating code together. Palette’s team built a synthetic corpus with a large open model as the teacher. Recipes defined each deck’s genre, length, layouts and user instructions, letting the team control the kinds of work represented. Plans varied from organized outlines to unstructured content dumps, so the model had examples of when to condense and select material. The resulting dataset contains around 1,000 decks and roughly 10,000 slides.
Each example includes a counterfactual explanation of a design decision: the reasoning considers an alternative and explains why it was rejected. For instance, a slide about quarterly revenue might use a bar chart instead of a table because the intended message is the upward trend, not the exact values. Another example considers a 62-character title: at 44 points it would take three lines and collide with the chart, while 36 points allows two lines and leaves space. These traces aim to teach the rule behind a choice, not just reproduce a layout.
Generated examples still need quality control. The team renders every deck and checks it for overlap and overflow using the same checker used at inference. Broken slides are repaired, and the explanation is rewritten to describe the original problem and why the correction works. In this loop, a detected failure becomes a training example for avoiding that failure later.
Faithfulness to supplied information proved harder than layout. A prompt rule alone didn’t reliably stop the teacher from inventing content when a brief requested more detail than it contained—for example, a six-by-five table based on only three bullets. Reference decks worked better: showing examples in the teacher’s prompt changed its output more reliably than adding further instructions. The teacher tended to copy the references, so they became a key part of keeping generated material grounded.
Directives give users control over slide form
Users can steer specific design decisions with short directives written in the plan inside double brackets. A directive such as [[make this a timeline]] can turn milestones that would otherwise appear in a table into a timeline. The designer passes the instruction into the brief, and the coder applies it when drawing the relevant slide.
The model learned to follow directives through its training data. Deck recipes included instructions from 12 categories, with multiple phrasings for each, so the model would learn the intended change instead of depending on one exact wording.

Figure 1. The same plan shown without a directive on the left and with [[make this a timeline]] on the right.
A harness checks and repairs the rendered deck
Palette doesn’t return raw model output directly. It first applies simple fixes for known errors, such as malformed color codes that could make every slide black. Then it renders slides and measures their geometry. The checker flags overlapping, clipped or off-slide text and sends affected slides to a separate editor model, which rewrites their code.
A rewrite is accepted only if the checker confirms the slide improved; otherwise, the original is kept. This gate means repair can improve a deck without allowing a failed rewrite to make the measured layout worse. In tests, the team generated 131 PresentBench decks and scored each with and without the harness. The harness raised scores by an average of 3.5 points.

Figure 2. The designer drafts the brief, the coder writes slide code in parallel, and the harness checks and repairs the slides.

Figure 3. The harness detects overlapping card titles and descriptions, then reflows the cards into a 2×2 grid.
Strong scores, with a design-language gap
PresentBench evaluates fundamentals, visual design, completeness, correctness and fidelity. Its test setup starts from a source document rather than a plan, so a separate frontier model drafted each plan for Palette. The reported comparisons cover three domains, with baseline figures taken from the PresentBench paper.
Palette ranks first in Economics and Education, where structured content and numeric accuracy carry weight. It places third in Talk, a more narrative and speech-driven domain where two closed systems score higher. Across the three domains, Palette averages 59.7, placing second behind NotebookLM at 60.8 and ahead of the other systems compared. The result is for a single 20B open weight model.

Figure 4. Palette ranks first in Economics and Education, third in Talk, and second on the three-domain mean.
Those scores measure deck quality, but not whether a deck matches a particular design language. The team says it knows of no benchmark for that question, leaving a central part of Palette’s intended use without a direct measure. PresentBench results therefore support its general deck-generation performance, while the claimed value of matching a team’s visual identity still needs a dedicated evaluation.
Next steps focus on verification and templates
The harness already computes signals that are cheap to verify: whether a slide renders, whether anything overlaps or overflows, and whether each fact can be traced to the brief. The team wants to use those checks as rewards in reinforcement learning, so the model learns to avoid errors during generation. Because the coder works one slide at a time, each slide can serve as a short, independently checked rollout for GRPO-style training.
Other planned work addresses figure-heavy decks and template adaptation. The team is exploring ways to extract figures from source documents, for example with Docling, and place them through the harness. It is also investigating whether output can be reskinned from one or two existing .pptx files without retraining.
Palette’s broader lesson is that structured generation benefits when a model’s work can be inspected by code. Separating decisions from layout, supplying examples that encode design intent, and checking rendered output creates a workflow that could also apply to charts, diagrams and interface layouts. Its current results make a case for that approach, while the lack of a design-language benchmark leaves an important part of the evaluation open.
===END===