Data analysis is only half the work. The other half is getting that analysis into a format someone can actually read. The QMD skill closes that gap by giving your OpenClaw agent direct access to Quarto — the document system that replaced R Markdown as the standard for reproducible technical documents.
What Quarto Is — and Why It Matters Here
Quarto is an open-source scientific and technical publishing system built by Posit (formerly RStudio). It's the successor to R Markdown, but unlike its predecessor, Quarto works natively with Python, Julia, and Observable JavaScript — not just R.
A .qmd file is a plain-text document that mixes three things: YAML metadata (title, author, output format), narrative prose in Markdown, and executable code chunks. When Quarto renders the document, it runs every code chunk, captures the output — tables, charts, computed values — and weaves everything into a finished document.
The result is reproducible. Every time the document renders, it re-executes the code against live data. That's exactly what you want for automated reports: the same document template, fresh data, new output every time.
What the QMD Skill Actually Does
The QMD skill gives your OpenClaw agent four capabilities:
- Read .qmd files — parse document structure, extract metadata and code chunks
- Write .qmd files — create new documents or modify existing ones programmatically
- Render documents — trigger Quarto CLI to produce HTML, PDF, or DOCX output
- Capture and report errors — surface render failures back to the agent for correction
That error-capture capability is what makes the skill genuinely useful for agentic workflows. Without it, a failed render would silently stall your agent. With it, the agent gets the full error output, can diagnose what went wrong — a missing package, a syntax error in a code chunk — and attempt a fix before re-rendering.
Installation
openclaw plugins install qmdAfter install, verify it's active:
openclaw plugins list | grep qmd
# qmd v1.1.0 built-in enabledIf the skill shows as enabled but render commands fail immediately, Quarto is not installed or not on PATH. That's the most common first-run failure. We'll handle that next.
The Quarto Prerequisite
The QMD skill is a wrapper around the Quarto CLI. Quarto must be installed separately on the host machine.
# Install Quarto CLI (macOS with Homebrew)
brew install --cask quarto
# Verify installation
quarto --version
# 1.4.557For Windows, download the installer from quarto.org. For Linux, use the .deb or .rpm package. After install, confirm Quarto is on your PATH — OpenClaw calls quarto render as a subprocess, so it needs to find the binary.
If your documents use Python code chunks, ensure the Python packages your documents import are installed in the environment OpenClaw runs in. If you use R code chunks, R must be installed and the relevant packages available. The skill doesn't manage dependencies — that's on you.
quarto install tinytex after installing Quarto. TinyTeX is a lightweight LaTeX distribution that Quarto manages automatically. Without it, PDF renders will fail with a "LaTeX not found" error.Configuration
After installation, the QMD skill creates a skill.md config in your agent's skills directory:
# skill.md — QMD skill configuration
skill: qmd
version: "1.1"
config:
default_output_format: html # html | pdf | docx
output_directory: "./reports" # where rendered files go
execute_timeout_seconds: 120 # max time for code execution
freeze_executed_chunks: false # set true to skip re-execution
quarto_binary: "quarto" # override if not on PATHThe output_directory setting matters for agents that generate reports on a schedule — point it somewhere your file manager or notification system watches. The execute_timeout_seconds is critical for documents with heavy computation; increase it for data-intensive reports or you'll get timeout errors mid-render.
Use Cases That Work Well
Automated Weekly Data Digests
The most common QMD skill application. An agent pulls data from a database or API, creates a parameterized Quarto template, populates it with this week's numbers, and renders to HTML. The output lands in a shared folder or gets sent via the AgentMail skill. No manual effort — the report just appears every Monday morning.
Here's the pattern for a parameterized report in Quarto:
---
title: "Weekly Performance Report"
params:
week_start: "2025-01-20"
team: "engineering"
format: html
---
```{python}
import pandas as pd
week = params['week_start']
df = pd.read_csv(f"data/{week}_metrics.csv")
df.describe()
```The agent swaps the params each week — same template, fresh data, consistent output format every time.
Data Analysis Output Formatting
Analysts use the QMD skill to turn exploratory analysis into shareable documents without leaving the agent interface. They run the analysis, the agent formats results into a Quarto document with proper section headers, interpretation prose, and code appendix, then renders to PDF for distribution. What used to take 30 minutes of manual formatting takes under two minutes.
Research Documentation Automation
Research agents combine the Web Search skill for information gathering with the QMD skill for output formatting. The agent searches, synthesizes, and writes a structured Quarto document that renders into a properly formatted research brief — with citations, tables, and sections automatically arranged.
Limitations Worth Knowing
The QMD skill doesn't manage Python or R package dependencies. If a code chunk imports a library that isn't installed, the render fails. You need to manage the environment separately — either ensure packages are pre-installed or use a virtual environment that OpenClaw activates before rendering.
Rendering speed depends entirely on what the code chunks do. A simple markdown-heavy document renders in under a second. A document with heavy pandas operations, ML model inference, or large data transformations can take minutes. The default 120-second timeout catches most cases, but increase it for compute-heavy templates.
Interactive Quarto features — Observable JS plots, Shiny widgets, HTML widgets — render to static output when the skill triggers quarto render. Full interactivity requires serving the rendered HTML from a web server, not just opening the file.
Common Mistakes
The number one mistake is assuming Quarto is already installed. It's not bundled with OpenClaw, not installed by the skill, and doesn't come with macOS or most Linux distributions. Check with quarto --version before anything else.
Second: forgetting to set output_directory to somewhere persistent. By default, rendered files go into a temp directory that gets cleaned up. Your reports disappear. Set an explicit output path.
Third: not setting execution timeouts for data-heavy documents. The default 120 seconds sounds generous, but a document that queries a slow database, processes large CSVs, and generates a dozen plots can easily exceed it. Set the timeout based on your worst-case render time, not average.
Frequently Asked Questions
What is a QMD file?
A QMD file is a Quarto Markdown document — a plain-text format that mixes narrative prose, code chunks (R, Python, Julia, or Observable), and YAML metadata. Quarto renders QMD files into HTML, PDF, Word, or presentation slides by executing the embedded code and weaving results into the output.
Do I need R installed to use the QMD skill?
Not necessarily. Quarto supports Python and Julia as primary engines, so you only need R if your documents use R code chunks. Python-based documents work with a standard Python install and the required packages. You do need Quarto CLI installed regardless of your code language.
What output formats does the QMD skill support?
The QMD skill supports HTML (default), PDF (requires LaTeX or Typst), and DOCX output formats. HTML renders fastest and requires no additional dependencies. PDF output requires a LaTeX distribution like TinyTeX, which Quarto can install automatically via quarto install tinytex.
Can agents write and render QMD files autonomously?
Yes. Agents with QMD skill access can create new .qmd files from scratch, populate them with data analysis code and narrative, then trigger rendering — all in a single multi-step workflow. This is the core pattern for automated reporting agents.
What happens if a code chunk fails during rendering?
Quarto halts rendering at the first failed code chunk by default. The QMD skill captures the error output and surfaces it to the agent, which can then attempt to fix the code and re-render. Set error: true in chunk options to allow rendering to continue past errors.
Is the QMD skill suitable for production report generation?
It works for structured, predictable reporting workloads — weekly summaries, data digests, fixed-format analysis outputs. For high-volume or highly dynamic production systems, evaluate whether a dedicated pipeline tool better fits your latency and reliability requirements.
You now understand what the QMD skill does, what it requires to work, and where it fits in automated reporting and documentation workflows. Install Quarto, install the skill, and render your first document. The gap between raw analysis and shareable output closes permanently.
R. Nakamura builds automated reporting systems for research and analytics teams. With a background in computational biology and five years working with R Markdown and Quarto pipelines, he focuses on making data outputs accessible without manual formatting work.