Charts for the
agent-native era.

Why Glyph exists

Every charting library predates LLMs. D3 (2011), Tableau (2003), Plotly (2014), Vega-Lite (2017) — all assume a human writes the code, reads the chart, and maintains the dashboard. When an agent tries to use them, the cracks show: imperative APIs that won't compose, non-deterministic output that can't be snapshot-tested, opaque internals that block lineage + audit, no programmatic verb surface to chain reliably. Glyph was built from scratch for the agent-native era — chart specs as JSON values, compilation as pure function, byte-stable SVG output, 50 MCP verbs as the primary interface.

What Glyph is — and what it isn't

Scope matters. Glyph picks a side on several axes that other tools straddle. If your use case lives on the other side of these lines, Glyph is not the right tool — and we'll tell you which tool is.

Use cases — agent-native computing

Concrete scenarios where Glyph is the right tool. Each one maps to one or a few MCP verbs; every output carries a gdf:// handle, lineage, audit findings, and is reproducible byte-for-byte.

glyph_describe("rides.csv")
glyph_render(spec, modalities)
glyph_drill(handle, selector)
glyph_explain(handle)

// agent A
const { uri } = await glyph_render(spec)
// agent B (different process)
await glyph_subscribe(uri)
const { uri: drill } =
  await glyph_drill(uri, sel)

const { svg, audit, trust } =
  await glyph_audit({ spec })
// trust.score: 47 / 100
// audit.findings: 3

vitest run __snapshots__/fig3.svg
# 679 tests — byte-identical
# 6-cell CI matrix (Node × OS)

glyph_preview(spec)
// → http://localhost:5174
// → SVG hydrates with declared interactions

$ glyph diff a.json b.json
[ replace /layers/0/mark
    "bar" → "area" ]
[ add /encoding/opacity 0.75 ]

Examples

Same JSON spec on the left, the rendered chart on the right.

Key innovations, visualized

Nine innovations that show how Glyph differs from D3 / Vega-Lite / Plotly / Tableau / Power BI. Each is one MCP verb call. None requires an LLM at runtime — every algorithm is deterministic + pure. For the full taxonomy see 55 capabilities and INNOVATION.md.

55 capabilities only Glyph ships

Every row below is a thing Glyph does today that no other charting tool ships — D3, Vega-Lite, Plotly, Tableau, Power BI, Observable Plot, Apache ECharts. Grouped into 11 categories and 3 uniqueness tiers. Architectural = nobody else could ship this without rewriting their core. Capability = nobody else has built it. Ergonomics = could be copied, but isn't.

Eight things no other charting library can do

Each of the demos below is a single MCP verb call on Glyph and a multi-week engineering project on every competitor. The reason isn't "more features" — it's the architecture: deterministic spec-only JSON + an embedded compute engine + an agent-native protocol layer.

glyph_morph_render({
  spec_a: { data: {source}, layers: [
    { mark: "area", stat: { type:"stack",
                            params:{offset:"zero"} } }
  ]},
  spec_b: { /* same, but offset:"expand" */ },
  duration_ms: 4000
})

// Agent A
const { uri } = await glyph_render(spec)
// uri = "gdf://abc/src"

// Agent B (different process / IDE)
await glyph_subscribe(uri)
const { uri: drill } = await glyph_drill(uri,
  { selector: { kind: "between", field: "z",
                from: 3, to: 99 } })

// Agent C (yet a third process)
await glyph_subscribe(drill)
const story = await glyph_explain(drill)
// walks lineage back to "uri" automatically

glyph_render({
  spec: { data:{source:"rides.csv"},
          layers:[{mark:"bar",
            encoding:{x:"hour",y:"rides"}}],
          link_group: "rides-q4" },
  modalities: ["chart","table","narrative"]
})
→ { svg, modalities: {
    table:     { columns, rows },
    narrative: { headline, highlights[] }
  }}

glyph_render({
  data: { source: "gdp.parquet" },
  layers: [{
    mark: "bar",
    encoding: { x:"gdp", y:"country", color:"country" }
  }],
  animation: {
    kind: "race",
    frame_field: "year",
    duration_ms: 8000
  }
})

const { svg, audit, trust } =
  await glyph_audit({
    spec,
    rules: ["axis", "scale",
            "encoding", "size"]
  })
// audit.findings: [...]
// trust.score: 47 / 100

// diff two saved specs
const patch = await glyph_spec_diff(a, b)

// apply elsewhere
const next = await glyph_spec_patch(a, patch)

// animate the transition
await glyph_morph_render({
  spec_a: a, spec_b: next,
  duration_ms: 5000
})

glyph_render({
  data: {
    shape: "topojson",
    source: "world.json"
  },
  projection: "equalEarth",
  layers: [
    { mark: "geoshape",
      encoding: { color: "value" } },
    { mark: "anomaly",  // built-in
      encoding: { value: "shipping_p99",
                  by: "country" } }
  ]
})

glyph_render({
  data: { shape: "graph",
          nodes, edges },
  layers: [{
    mark: "node-link",
    kind: "causal"   // enables cycle audit
  }]
})
// throws RuleAuditFailure on cycle
// → agent gets actionable feedback,
//   not a bowl of spaghetti

The Whyboard — agents tell stories, not just charts

One chart answers "what does this look like?". The Whyboard answers "why?" When the user asks "why did rides spike at 8am?", Glyph doesn't return a single chart — it returns a deterministic tree of diagnostics: a root, then one branch each for anomaly detection, variance decomposition, and forecast. Every leaf is a real DataHandle with chained lineage — click it, query it, drill in.

glyph_whyboard({
  handle_id: "rides_today",
  question: "Why did rides spike at 8am?",
  link_group: "investigate-q4"
})

→ {
  root: { kind: "root", explanation: {...},
    children: [
      { kind: "anomaly",   uri: "gdf://abc/a1", ... },
      { kind: "decompose", uri: "gdf://abc/d1", ... },
      { kind: "forecast",  uri: "gdf://abc/f1", ... }
    ]
  }
}

Playground — try a spec

Five preset chart types, each with its full Glyph spec and the byte-stable SVG it compiles to. Click a preset to swap both panes. The specs are valid — paste any of them into glyph_render and you'll get back the exact SVG shown.

Open the live playground → Paste a CSV, edit a spec, see the audit panel update live, share via URL or Gist.

{
  "data": { "source": "rides.csv" },
  "layers": [{
    "mark": "bar",
    "encoding": {
      "x": "hour",
      "y": "rides"
    }
  }]
}

{
  "data": { "source": "rides.csv" },
  "layers": [{
    "mark": "line",
    "encoding": {
      "x": "hour",
      "y": "rides"
    }
  }]
}

{
  "data": { "source": "rides.csv" },
  "layers": [{
    "mark": "area",
    "encoding": {
      "x": "hour",
      "y": "rides"
    },
    "opacity": 0.75
  }]
}

{
  "data": { "source": "iris.csv" },
  "layers": [{
    "mark": "point",
    "encoding": {
      "x": "sepal_length",
      "y": "sepal_width",
      "color": "species"
    }
  }]
}

{
  "data": { "source": "browsers.csv" },
  "coordinates": { "kind": "polar" },
  "layers": [{
    "mark": "arc",
    "encoding": {
      "theta": "share",
      "color": "browser"
    }
  }]
}

Get started

Install @glyph/mcp once. Register it with your agent's MCP config. Then ask the agent to render a chart. The same flow works in Claude Code, Codex CLI, Cursor, Copilot CLI, and Gemini CLI — anything that speaks MCP.

npx -y @glyph/mcp --version

claude mcp add glyph -- npx -y @glyph/mcp

$ claude
> render a bar chart of rides.csv by hour
[Claude calls glyph_describe, glyph_render]
[returns SVG handle: gdf://abc/src]

npx -y @glyph/mcp --version

[mcp_servers.glyph]
command = "npx"
args    = ["-y", "@glyph/mcp"]

$ codex
> read rides.csv and render rides per hour
[Codex calls glyph_render, returns SVG]
[handle: gdf://abc/src]

import { compileSpec, renderSvg } from "@glyph/core";
import { createDuckDBEngine, materializeSpec } from "@glyph/duckdb";

const engine = await createDuckDBEngine();
const m = await materializeSpec(engine, {
  data: { source: "rides.csv", format: "csv" },
  layers: [{ mark: "bar", encoding: { x: "hour", y: "rides" } }]
});
const scene = compileSpec({
  spec: m.effectiveSpec, rows: m.result.rows, schema: m.handle.schema
});
const svg = renderSvg(scene);

Comparison — objective feature matrix

No scoring, no totals — just yes / partial / no across 16 features. Glyph picks different trade-offs from each competitor; rows where Glyph differs are where it earns its keep. Sources: each tool's official documentation as of 2026-05. Readers should weight the rows that matter for their use case.

yes — built in  ·  partial — via plugin, separate package, or in-product only  ·  no — not supported.
Tableau and Power BI have proprietary compute engines that are not embeddable in your own code. Vega-Lite is deterministic only when rendered headless (vega-cli); browser-side it inherits browser float drift. D3 is a primitive toolkit, so “mark types” is not a meaningful count.