Teaching small open models to generate on-brand slide decks

Hugging Face has introduced Palette, a system that enables small, open-weight language models to generate slide decks adhering to specific design languages. Published on November 3, 2026, this approach addresses the limitations of large frontier models, which often impose a generic house style and may pose confidentiality risks. By fine-tuning a 20B parameter model with synthetic data and a robust verification harness, the team achieved top-tier performance on structured content benchmarks while maintaining full ownership of the infrastructure and output.

What happened

Frontier large language models are capable of generating high-quality slide decks, but they tend to converge on a similar aesthetic regardless of prompting. This "AI-generated" look makes it difficult for organizations to enforce their own brand guidelines or templates. Furthermore, using closed-source models for sensitive corporate content raises data privacy concerns. Small open-weight models offer a solution for ownership and customization, but they historically struggle with the geometric precision required for layout design, often producing broken slides with overlapping text or missing elements.

Palette tests the hypothesis that a small model can compete with larger systems if trained correctly. The team fine-tuned a 20B parameter model using the IBM Design Language as its target style. The resulting system splits the generation process into two distinct roles: a designer that plans the content and structure, and a coder that writes the JavaScript to render each slide. On the PresentBench evaluation suite, Palette ranked first in the Economics and Education domains and second overall among the tested systems, demonstrating that specialized training can overcome the inherent limitations of smaller architectures.

The project highlights a shift from relying solely on model scale to improving data quality and inference safeguards. By generating synthetic training data that includes the reasoning behind design choices and implementing a check-and-repair harness, the team created a system that produces reliable, on-brand outputs. This method allows organizations to run the model on their own hardware, ensuring that confidential data never leaves their secure environment.

How it works

Palette mimics the human workflow of creating presentations by separating editorial judgment from geometric execution. A single LoRA adapter manages two roles. The designer role reads the input plan and produces a structured JSON brief containing the palette, typography, and content for each slide. The coder role then takes individual slide specifications from this brief and writes pptxgenjs JavaScript code to render them. This separation allows the coder to focus exclusively on layout arithmetic, such as calculating font sizes and coordinates, while the designer handles narrative flow. Because each slide is generated independently, the coding stage can run in parallel, speeding up production by six to seven times.

Since no public dataset exists that links design rationale to slide code, the team synthesized approximately 1,000 decks comprising 10,000 slides using a large open teacher model. Crucially, each training example includes counterfactual reasoning, explaining why certain design choices were made and others rejected. For instance, the data might explain that a bar chart was chosen over a table to highlight a trend rather than exact figures. This teaches the model the rules behind design decisions, not just the final output. The synthetic data was further refined by rendering every slide and using a geometry checker to identify and repair errors like text overflow, turning failures into high-quality training examples.

To ensure reliability at inference time, Palette employs a harness that validates every generated deck. Simple rules fix formatting errors, while a geometry checker identifies visual issues like overlapping elements. If a slide fails validation, a separate editor model attempts to rewrite the code. The new version is only accepted if the checker confirms an improvement, ensuring the repair process cannot degrade the output. This safety net allows the system to correct common small-model mistakes, such as titles blending into backgrounds, without human intervention.

Key details

• The system uses a 20B parameter open-weight model fine-tuned with LoRA adapters to preserve base model capabilities.
• Training data includes around 1,000 synthetic decks with counterfactual reasoning that explains design choices and rejections.
• A parallel coding architecture allows individual slides to be generated simultaneously, improving speed by 6–7×.
• The inference harness checks for geometric errors like text overlap and only accepts repairs that measurably improve the slide.
• Palette ranked first on PresentBench for Economics and Education domains, and second overall with a mean score of 59.7.
• Users can control specific design outcomes using directives wrapped in [[ ]], such as [[make this a timeline]].

Why it matters

For engineering teams building internal tools or customer-facing applications, Palette offers a path to customizable AI without the cost and risk of proprietary APIs. The ability to run a competent design model on local infrastructure means sensitive business data remains within corporate firewalls. This is critical for industries with strict compliance requirements where sending documents to third-party servers is prohibited. Additionally, the modular nature of the output, separated into a JSON brief and rendering code, allows developers to intervene programmatically or manually adjust specific slides without regenerating the entire deck.

The methodology also provides a blueprint for other structured generation tasks beyond presentations. The combination of synthetic data with explicit reasoning traces and a verification harness can be applied to generating UI layouts, charts, or diagrams. By prioritizing verifiable correctness over raw generative fluency, developers can build more reliable agents. The finding that reference examples influence teacher models more than prompt rules suggests that curating high-quality few-shot examples is more effective than complex instruction tuning for certain tasks.

What you can do

• Implement a verification harness for any generative task where output structure can be checked programmatically, such as valid JSON or non-overlapping UI elements.
• Generate synthetic training data that includes counterfactual reasoning to teach models the logic behind decisions, not just the outcomes.
• Separate complex generation tasks into distinct roles, such as planning and execution, to allow for parallel processing and specialized fine-tuning.
• Use reference examples in prompts to steer teacher models during data synthesis, as they often follow patterns more reliably than abstract rules.
• Adopt a safe-repair strategy where automated fixes are only applied if a validator confirms the output has improved, preventing degradation.
• Explore lightweight template adaptation by re-skinning outputs from existing files rather than retraining models for every new brand guideline.