IBM's open-weight Palette: a 20B model builds decks in your design language, with a checker as backstop
According to an IBM Research blog post dated November 3, 2026, Palette fine-tunes a 20B open-weight model on about 1,000 synthetic presentations and roughly 10,000 slides, splitting design planning and per-slide code generation into two roles, with a rendered-geometry checking framework to repair overlaps and overflow.
What changed
Three IBM Research authors published Palette on the Hugging Face blog on November 3, 2026: a system that trains a small open-weight model to produce a complete presentation on its own. According to the post, Palette is a 20B model fine-tuned with a LoRA adapter on about 1,000 synthetic presentations and roughly 10,000 slides; the layouts in the training data follow IBM's design language. The article does not name the base model. It divides the work into two roles, both handled by the same LoRA adapter. A designer reads the plan and writes a structured JSON brief containing the color palette, font system, per-slide layout, exact content, and a short rationale. A coder takes one slide specification, writes reasoning first, and then writes pptxgenjs JavaScript to draw that slide. The original says that because each slide's context is fixed before any code is written, coder calls can run in parallel per slide, making the coding phase about 6 to 7 times faster. The authors also mention a training detail: coder samples are about five times longer than designer samples, and a simple mix would leave the designer undertrained, so they oversample designer samples five times. Users can write instructions in double brackets in the plan, for example to change a milestone into a timeline, specify tone or audience, or ask to omit certain content. The data recipe covers 12 instruction categories, each with multiple phrasings, so the model learns intent rather than fixed phrases. Model output is not delivered directly. Each deck first passes through a check-and-repair framework: simple rules fix malformed color codes, then each slide is rendered and its geometry measured, flagging text that overlaps, is clipped, or runs off the canvas. That slide's code is sent to another editor model for rewriting, and the rewrite is kept only when the checker confirms an improvement; otherwise the original is restored. The authors report that across 131 PresentBench presentations, this framework produced an average gain of 3.5 points. PresentBench scores five dimensions: basic, visual design, completeness, correctness, and faithfulness. Palette ranked first on Economics and Education and third on the more narrative Talk category. Its three-domain mean was 59.7, behind NotebookLM's 60.8, placing it second. The baseline numbers come from the PresentBench paper, and in these runs the plans were drafted by another frontier model from the source documents.
What it means for developers
The practical impact for developers centers on three points. First, the delivery shape changes: Palette does not generate an entire deck in one shot but produces inspectable intermediates layer by layer: a plan, a JSON brief, and per-slide code. The brief is readable and editable, and a person or another agent can change one slide's layout without regenerating the whole deck. That means integrators need to manage the brief as a versioned interface rather than as internal temporary data. Once the layout schema changes, downstream tools for editing a single slide will break first. Second, the call shape changes. Per-slide parallelism means one task turns from one long request into a dozen short requests, with timeouts, retries, rate limits, and costs counted per slide. For self-hosted services, that makes local retries and caching easier, but also makes it easier to lose control of costs: a failed slide rewrite triggers an extra editor-model call. The checking framework is not free; it puts a renderer and a second model in the return path, so end-to-end latency and the compute bill are not the same as for a single generation. Third, the capability boundary is clearer. The authors acknowledge that PresentBench only measures whether a deck is good, not whether it follows a particular design language, and say they do not know of a benchmark that does. In other words, the claim of training to your design language currently has no ready third-party metric. Another shortcoming they name is graphic-heavy decks: extracting images from source documents and placing them with the help of the checking framework remains a next step. In addition, lightly applying existing templates, by restyling from one or two of your own pptx files without retraining, is only an exploratory direction. There is also an easily overlooked dependency: in the PresentBench runs, the plan was drafted by another frontier model from the source documents. That is, the end-to-end result is a combination of a planner plus Palette, and self-hosting Palette does not automatically provide that upstream chain. Teams with confidential content that must stay entirely on an intranet will need to fill that step themselves.
Integration and evaluation
The following are suggestions and conditional analysis based on the original article, not reported facts. Recommendation one: first decide whether to adopt a two-stage pipeline of brief plus per-slide code. The reported change is that a single adapter handles both designer and coder, and per-slide calls can run in parallel; the original says the coding phase is about 6 to 7 times faster. The choice to make is to define the system interface at the structured brief rather than asking the model directly for a finished file. This applies when each batch needs 10 to 20 slides and there is a real need to change just one slide; if you only produce an occasional short deck, the extra orchestration, schema maintenance, and rendering may well eat the gains from parallelism. A measurable criterion: fix a batch of source documents, record the end-to-end wall-clock time for each 15-slide deck, the number of retries per slide, and the geometry defect rate (the share of slides with overlap or overflow), and compare that with one-shot end-to-end generation. Recommendation two: before putting check-and-repair into the production path, build your own automatically measurable rendering and geometry checks. The reported basis is a 3.5-point average gain across 131 decks, with rewrites kept only when the checker confirms improvement. The choice is to make quantifiable improvement a hard gate for accepting a rewrite, rather than letting the editor model overwrite unconditionally. The precondition is critical: you need a checker that can render output and measure overlap, clipping, and overflow. The blog does not release that checker's implementation, so this part is yours to build. Measurable criteria: the share of flagged slides, the share of rewrites accepted, and the difference between framework on and off on your own scoring rubric. If the acceptance rate is very low and scores barely move, the editor-model calls are just cost. Recommendation three: write layout and content preferences as structured instructions inside the plan, rather than piling them into a long prompt. The reported basis is training that covers 12 instruction categories, each with multiple phrasings, plus examples such as changing something into a timeline. What to do is turn requests such as "change it to a timeline," "no prices," or "for the board" into fields rather than free text. The precondition is that your plan-generation step can reliably produce these instructions; if end users type them freely, first validate adherence. A measurable criterion: express the same intent five different ways in the same plan, then measure intent achievement and format regression rates. There are two more operational suggestions at the evaluation level. If you want to reproduce or compare PresentBench scores, fix the plan source first, because the original setting's scores mix in another frontier model's planning ability; comparing directly with a self-built chain would misjudge Palette's own contribution. Second, build a small-scale check for whether it follows your own design language, for example by sampling and comparing font, palette, and grid usage against internal rules, because the public benchmark does not cover this dimension. On integration shape, the original describes open weights and self-hosting and does not provide a hosted API. If a team self-hosts, capacity planning for a 20B deployment and for per-slide concurrent calls needs separate sizing; the original provides no latency or cost numbers for this.
Limits and open questions
The original provides only research and evaluation information; key engineering materials are still missing. The article says "open weights" throughout but does not give a weight download location or license terms. Weight availability is not the same as an open-source license; confirm commercial use, redistribution, and derivative training with the publisher. The base model is not named, only described as 20B, so it is impossible to judge what capabilities and limits it inherits. The checker implementation, the brief schema, and the full set of instruction categories are not public, so reproduction depends on building them yourself. The evaluation scope is also limited: only three domains are reported, the baseline numbers come from the PresentBench paper, the plans were drafted by another frontier model, the authors concede that no benchmark measures design-language adherence, and the 3.5-point framework gain is limited to their 131 decks and their scoring method. Extracting and placing images for graphic-heavy decks, lightly applying templates, and using checker signals as reinforcement-learning rewards are all explicitly next steps rather than current capabilities. This 20B version of Palette is not currently in KimiSeek's model catalog, and the original provides no hosted API; any statement about availability or access points to the publisher, IBM Research.
Illustrations from the original report



