Initial release: agent-usage shares through 2026-06

.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,84 @@
+---
+pretty_name: Agent Usage on the Hugging Face Hub
+tags:
+  - analytics
+  - agents
+configs:
+  - config_name: monthly
+    default: true
+    data_files: data/monthly/*.parquet
+  - config_name: daily
+    data_files: data/daily/*.parquet
+---
+
+# Agent Usage on the Hugging Face Hub
+
+**Coding agents are real users of the Hugging Face Hub.** Claude Code, Codex, Cursor, and a growing list of harnesses are searching for models, building and pushing datasets, training models on [Jobs](https://huggingface.co/docs/hub/jobs), spinning up Spaces — tens of millions of requests so far ([hf CLI for agents](https://huggingface.co/blog/hf-cli-for-agents)). Now there's public data on which ones.
+
+Requests made through the `huggingface_hub` library (including the `hf` CLI) carry an [`agent/<name>` User-Agent token](https://huggingface.co/docs/hub/agents-overview) identifying the harness. This dataset publishes **each harness's share of that agent-attributed traffic**, month by month and day by day, updated by a scheduled [HF Job](https://huggingface.co/docs/hub/jobs).
+
+![Current leaderboard](assets/leaderboard.png)
+
+_Named harnesses ranked by share of requests, data through **2026-06** · updated 2026-07-02. The **Dataset Viewer** at the top of this page lets you browse, sort, and filter both tables — no code needed._
+
+## What you can see
+
+- **Who's calling the Hub** — the monthly leaderboard of named harnesses, and how it shifts as new tools launch and register.
+- **Usage styles** — compare request share with user share. An agent with 30% of requests but 8% of users is a small crowd running heavy automated pipelines; the reverse means many users, each doing a little.
+- **Day-by-day detail** — the `daily` config picks up what monthly numbers smooth over: launch spikes, growth curves, weekday-vs-weekend patterns.
+
+## Get your harness on the board
+
+If you build a harness, register it to make sure your agent isn't missed — unregistered tools are counted only as `unknown`.
+
+Attribution is automatic: `huggingface_hub` detects registered harnesses from environment variables and reports them in the User-Agent. To register, follow [Register your agent harness](https://huggingface.co/docs/hub/agents-overview#register-your-agent-harness) — a Pull Request adding your tool to [`agent-harnesses.ts`](https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/src/agent-harnesses.ts). No release is needed on either side: installed clients refresh the registry within a day, and your harness appears from the next monthly snapshot.
+
+Only traffic through the Python `huggingface_hub` library (including the `hf` CLI) is attributed; direct HTTP calls to the Hub API are not counted. To confirm detection works, run inside your harness:
+
+```bash
+python -c "from huggingface_hub.utils import build_hf_headers; print(build_hf_headers()['user-agent'])"
+# should contain agent/<your-id>
+```
+
+## Columns
+
+| column          | description                                                                                                  |
+| --------------- | ------------------------------------------------------------------------------------------------------------ |
+| `month` / `day` | period the share is computed over                                                                            |
+| `agent`         | harness name from the `agent/<name>` token; `unknown` = token present but no registered name                 |
+| `pct_requests`  | harness's share of agent-attributed `huggingface_hub` requests in the period (0–100; sums to 100 per period) |
+| `pct_users`     | same, for distinct authenticated users — someone using two harnesses counts once for each                    |
+
+## Loading programmatically
+
+```python
+from datasets import load_dataset
+
+monthly = load_dataset("huggingface/agent-usage", "monthly", split="train")
+```
+
+```sql
+-- DuckDB: full monthly history in one query
+SELECT month, agent, pct_requests
+FROM 'hf://datasets/huggingface/agent-usage/data/monthly/*.parquet'
+WHERE agent != 'unknown'
+ORDER BY month, pct_requests DESC;
+```
+
+```python
+import polars as pl
+
+daily = pl.scan_parquet("hf://datasets/huggingface/agent-usage/data/daily/*.parquet")
+```
+
+New months append as new parquet files, so these queries always return the full history unchanged.
+
+## Reading the data
+
+- **This measures Hub usage, not overall agent popularity.** A widely used tool that rarely touches the Hugging Face Hub will rank low here.
+- **Shares are zero-sum.** A falling share doesn't mean falling usage — total agent traffic is growing, so a harness can double its requests while its share shrinks.
+- **Start month-over-month comparisons from May 2026.** The `agent/` token rolled out April 3 and harnesses added detection at different times, so April reflects the rollout, not relative usage.
+- **Smooth daily shares** with a 7-day rolling mean — weekends and small denominators make single days noisy.
+- **Attribution is self-declared** (a User-Agent token set by the client library) and covers Python-library traffic only.
+
+_Built by [`build_local.py`](./build_local.py) (bundled in this repo) on a scheduled HF Job — only relative shares are published._

agent_usage.py

@@ -0,0 +1,260 @@
+"""Chart + table helpers for the Hub agent-usage leaderboard.
+
+Used by build_local.py (the scheduled HF Job) to render the PNGs embedded in
+the dataset card. This module only ever touches the *derived* public data
+(relative shares); fetching + deriving from the private source lives in
+build_local.py.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import matplotlib.dates as mdates
+import matplotlib.pyplot as plt
+import pandas as pd
+from matplotlib import rcParams
+from matplotlib.figure import Figure
+
+# --------------------------------------------------------------------------- #
+# Constants
+# --------------------------------------------------------------------------- #
+
+# Published derived dataset (used when no local data dir is given).
+DERIVED_REPO = "huggingface/agent-usage"
+
+ROLLOUT_DATE = "2026-04-03"  # agent/ UA token rollout — before this is noise
+
+# HF brand palette — https://huggingface.co/brand
+YELLOW = "#FFD21E"   # primary accent — leader bar
+ORANGE = "#FF9D00"   # secondary accent
+SLATE = "#1F2937"    # near-black bars / first line
+INK = "#111827"      # body text
+MUTED = "#6B7280"    # HF gray — axes, footers
+GRID = "#E5E7EB"     # light gridline
+BG = "#FFFFFF"
+
+# Stable categorical line colours (assigned by agent order).
+LINE_COLORS = [
+    SLATE, ORANGE, "#2563EB", "#059669", "#DC2626",
+    "#7C3AED", "#0891B2", "#CA8A04",
+]
+
+
+def set_brand_style() -> None:
+    """Apply HF-flavoured matplotlib defaults (clean sans-serif, white bg)."""
+    rcParams.update(
+        {
+            "font.family": "sans-serif",
+            "font.sans-serif": [
+                "Source Sans Pro", "Source Sans 3",
+                "Helvetica Neue", "Helvetica", "Arial", "DejaVu Sans",
+            ],
+            "font.size": 11,
+            "text.color": INK,
+            "savefig.facecolor": BG,
+            "axes.facecolor": BG,
+            "figure.facecolor": BG,
+        }
+    )
+
+
+# --------------------------------------------------------------------------- #
+# Selectors
+# --------------------------------------------------------------------------- #
+
+def available_months(monthly: pd.DataFrame) -> list[str]:
+    return sorted(monthly["month"].dropna().unique().tolist())
+
+
+def latest_month(monthly: pd.DataFrame) -> str:
+    return max(available_months(monthly))
+
+
+def leaderboard_table(
+    monthly: pd.DataFrame,
+    month: str | None = None,
+    top_n: int = 10,
+    exclude_unknown: bool = True,
+) -> pd.DataFrame:
+    """Ranked top-N agents for a month, ready to display."""
+    month = month or latest_month(monthly)
+    df = monthly.query("month == @month")
+    if exclude_unknown:
+        df = df[df["agent"].str.lower() != "unknown"]
+    df = df.sort_values("pct_requests", ascending=False).head(top_n).reset_index(drop=True)
+    out = df[["agent", "pct_requests", "pct_users"]].copy()
+    out.insert(0, "rank", range(1, len(out) + 1))
+    out["pct_requests"] = out["pct_requests"].round(2)
+    out["pct_users"] = out["pct_users"].astype("Float64").round(2)
+    return out
+
+
+def top_agents(
+    monthly: pd.DataFrame,
+    month: str | None = None,
+    n: int = 5,
+    exclude_unknown: bool = True,
+) -> list[str]:
+    """Top-N agent names by share in the given month (default: latest)."""
+    return leaderboard_table(monthly, month, n, exclude_unknown)["agent"].tolist()
+
+
+# --------------------------------------------------------------------------- #
+# Figures
+# --------------------------------------------------------------------------- #
+
+def leaderboard_figure(
+    monthly: pd.DataFrame,
+    month: str | None = None,
+    top_n: int = 10,
+    show_unknown: bool = True,
+) -> Figure:
+    """Horizontal-bar snapshot leaderboard, HF-brand register.
+
+    Named harnesses are ranked as usual; `unknown` (unregistered tools) sits as
+    a muted gray bar at the bottom — an honest part of the picture and the
+    reason to register a harness, without reading as part of the race.
+    """
+    set_brand_style()
+    month = month or latest_month(monthly)
+    table = leaderboard_table(monthly, month, top_n, exclude_unknown=True)
+
+    fig = Figure(figsize=(9.2, 9.2), facecolor=BG)
+    fig.text(0.06, 0.935, "Agents calling the Hugging Face Hub",
+             fontsize=22, color=INK, fontweight="bold")
+    fig.text(0.06, 0.895, f"Share of agent-attributed huggingface_hub requests, {month}",
+             fontsize=13, color=MUTED)
+
+    ax = fig.add_axes((0.06, 0.10, 0.88, 0.74))
+    # rows bottom-to-top: (label, pct, kind) with unknown pinned at the bottom
+    rows = [(r["agent"], float(r["pct_requests"]), "named")
+            for _, r in table.iloc[::-1].iterrows()]
+    if show_unknown:
+        unk = monthly.query("month == @month and agent == 'unknown'")
+        if len(unk):
+            rows.insert(0, ("unknown (unregistered)", float(unk["pct_requests"].iloc[0]), "unknown"))
+    if not rows:
+        ax.text(0.5, 0.5, "no data", ha="center", va="center", color=MUTED)
+        return fig
+    xmax = max(pct for _, pct, _ in rows)
+    ax.axvline(0, color=MUTED, linewidth=0.6, zorder=1)
+
+    top_idx = len(rows) - 1  # top *named* harness leads
+    for i, (label, pct, kind) in enumerate(rows):
+        is_unknown = kind == "unknown"
+        is_top = i == top_idx
+        bar_colour = GRID if is_unknown else (YELLOW if is_top else SLATE)
+        ax.barh(i, pct, color=bar_colour, height=0.62, zorder=2)
+        ax.text(-xmax * 0.022, i, label, va="center", ha="right",
+                fontsize=12 if is_unknown else 14,
+                fontstyle="italic" if is_unknown else "normal",
+                fontweight="bold" if is_top else "normal",
+                color=MUTED if is_unknown else INK)
+        ax.text(pct + xmax * 0.012, i, f"{pct:.1f}%", va="center", ha="left",
+                fontsize=14, fontweight="bold",
+                color=MUTED if is_unknown else (ORANGE if is_top else INK))
+
+    ax.set_yticks([]); ax.set_xticks([])
+    for s in ("top", "right", "left", "bottom"):
+        ax.spines[s].set_visible(False)
+    ax.set_xlim(-xmax * 0.50, xmax * 1.15)
+    ax.set_ylim(-0.7, len(rows) - 0.3)
+
+    fig.text(0.06, 0.040,
+             f"Source: hf.co/datasets/{DERIVED_REPO}  ·  self-declared agent/ User-Agent tokens.",
+             fontsize=10, color=MUTED)
+    return fig
+
+
+def trend_figure(
+    daily: pd.DataFrame,
+    agents: list[str],
+    smooth: bool = True,
+    since: str = ROLLOUT_DATE,
+) -> Figure:
+    """Daily share-over-time lines for the given agents, HF-brand register.
+
+    ``smooth`` applies a 7-day centred rolling mean (min_periods=3) to absorb
+    weekend dips and small-denominator noise in the early days.
+    """
+    set_brand_style()
+    df = daily[daily["day"] >= since].copy()
+    df = df[df["agent"].isin(agents)]
+    df["day"] = pd.to_datetime(df["day"])
+
+    fig = Figure(figsize=(11, 6.2), facecolor=BG)
+    fig.text(0.06, 0.93, "Agent share of Hub requests over time",
+             fontsize=20, color=INK, fontweight="bold")
+    sub = "7-day rolling mean" if smooth else "raw daily share"
+    fig.text(0.06, 0.885, f"huggingface_hub  ·  {sub}  ·  since {since}",
+             fontsize=12.5, color=MUTED)
+
+    ax = fig.add_axes((0.06, 0.13, 0.80, 0.70))
+    if df.empty:
+        ax.text(0.5, 0.5, "no data", ha="center", va="center", color=MUTED)
+        return fig
+
+    ymax = 0.0
+    labels = []  # (y_at_end, agent, colour) for de-collided right-hand labels
+    last_x = None
+    for idx, agent in enumerate(agents):
+        s = (
+            df[df["agent"] == agent]
+            .sort_values("day")
+            .set_index("day")["pct_requests"]
+            .astype(float)
+        )
+        if s.empty:
+            continue
+        if smooth:
+            s = s.rolling(7, center=True, min_periods=3).mean()
+        colour = LINE_COLORS[idx % len(LINE_COLORS)]
+        ax.plot(s.index, s.values, color=colour, linewidth=2.2, zorder=3)
+        valid = s.dropna()
+        if not valid.empty:
+            labels.append([float(valid.iloc[-1]), agent, colour])
+            last_x = valid.index[-1]
+            ymax = max(ymax, float(valid.max()))
+
+    ax.set_ylim(0, ymax * 1.12 if ymax else 1)
+
+    # De-collide right-hand direct labels: nudge apart by a min vertical gap
+    if labels and last_x is not None:
+        gap = (ymax * 1.12) * 0.045  # ~4.5% of axis height
+        labels.sort(key=lambda r: r[0])
+        for prev, cur in zip(labels, labels[1:]):
+            if cur[0] - prev[0] < gap:
+                cur[0] = prev[0] + gap
+        for y, agent, colour in labels:
+            ax.annotate(
+                f" {agent}",
+                xy=(last_x, y), xytext=(6, 0), textcoords="offset points",
+                va="center", ha="left", fontsize=11.5, color=colour,
+                fontweight="bold", annotation_clip=False,
+            )
+    ax.yaxis.set_major_formatter(lambda v, _: f"{v:.0f}%")
+    ax.grid(axis="y", color=GRID, linewidth=0.8)
+    ax.set_axisbelow(True)
+    for s in ("top", "right"):
+        ax.spines[s].set_visible(False)
+    for s in ("left", "bottom"):
+        ax.spines[s].set_color(MUTED)
+    ax.tick_params(colors=MUTED, labelsize=10)
+    ax.xaxis.set_major_locator(mdates.AutoDateLocator())
+    ax.xaxis.set_major_formatter(mdates.ConciseDateFormatter(ax.xaxis.get_major_locator()))
+    # room for the right-hand direct labels
+    ax.margins(x=0.02)
+
+    fig.text(0.06, 0.035,
+             f"Source: hf.co/datasets/{DERIVED_REPO}  ·  share of agent-attributed huggingface_hub requests.",
+             fontsize=10, color=MUTED)
+    return fig
+
+
+def save_png(fig: Figure, path: str | Path) -> Path:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(path, dpi=200, bbox_inches="tight", pad_inches=0.4, facecolor=BG)
+    plt.close(fig)
+    return path

build_local.py

@@ -0,0 +1,164 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#   "huggingface_hub>=0.27",
+#   "pandas>=2.0",
+#   "pyarrow>=15",
+#   "matplotlib>=3.8",
+# ]
+# ///
+"""Build the public-safe derived view of the Hub's agent-usage telemetry.
+
+The source dataset id is injected via the AGENT_USAGE_SRC env var (on Jobs:
+`-e AGENT_USAGE_SRC=...`), so this public script never names it.
+
+This is the scheduled HF Job body. It:
+  1. fetches the private source (monthly + daily parquets)
+  2. keeps only the public columns (relative shares; raw counts are never
+     published) and only registered harness rows (the rest fold into `unknown`)
+  3. writes derived parquets, renders the card PNGs, and pushes everything
+     (data + charts + card + this script) to the public dataset repo
+"""
+
+import os
+from datetime import date
+from pathlib import Path
+
+import pandas as pd
+from huggingface_hub import snapshot_download
+from huggingface_hub.constants import ENDPOINT
+from huggingface_hub.utils import get_session
+
+import agent_usage as au
+
+SRC = os.environ.get("AGENT_USAGE_SRC")
+if not SRC:
+    raise SystemExit("Set AGENT_USAGE_SRC to the source dataset id (on Jobs: -e AGENT_USAGE_SRC=...)")
+# Allowlist: only these columns are ever published. Anything else in the source
+# (whatever it is, now or later) is dropped by construction.
+KEEP = {"month", "day", "agent", "pct_requests", "pct_users"}
+# Publish the library-level rows only: the CLI source is a strict subset of
+# huggingface_hub (the CLI imports the library), so keeping both would double-count.
+PUBLISH_SOURCE = "huggingface_hub"
+ROLLOUT_MONTH = "2026-04"            # skip pre-rollout monthly files (mostly empty)
+
+# The `agent` value is extracted server-side from raw User-Agent strings, so it
+# is arbitrary user-controlled input. Sanitize rows the same way KEEP sanitizes
+# columns: only registered harness names are published; everything else folds
+# into `unknown` (which is also what the card promises for unregistered tools).
+# Fail loud if the registry is unreachable — never publish unfiltered tokens.
+_resp = get_session().get(f"{ENDPOINT}/api/agent-harnesses", timeout=10)
+_resp.raise_for_status()
+PUBLISH_AGENTS = set(_resp.json()["harnesses"]) | {"unknown"}
+
+HERE = Path(__file__).parent
+OUT = HERE / "preview"
+DATA = OUT / "data"
+
+
+def derive(folder: str, key_col: str) -> pd.DataFrame:
+    """Pull one granularity from the source, drop totals, write derived parquets."""
+    src_root = Path(
+        snapshot_download(SRC, repo_type="dataset", allow_patterns=f"data/{folder}/*.parquet")
+    )
+    out_dir = DATA / folder
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    frames = []
+    for parquet in sorted((src_root / "data" / folder).glob("*.parquet")):
+        # monthly: skip files before rollout; daily: keep all (chart filters by day)
+        if folder == "monthly" and parquet.stem < ROLLOUT_MONTH:
+            continue
+        df = pd.read_parquet(parquet)
+        if key_col not in df.columns:
+            df[key_col] = parquet.stem
+        if "source" in df.columns:
+            df = df[df["source"] == PUBLISH_SOURCE]
+        df = df[[c for c in df.columns if c in KEEP]]
+        # Fold unregistered tokens into `unknown`, then merge the folded rows.
+        df.loc[~df["agent"].isin(PUBLISH_AGENTS), "agent"] = "unknown"
+        group_cols = [c for c in df.columns if not c.startswith("pct_")]
+        df = df.groupby(group_cols, as_index=False).sum()
+        df.to_parquet(out_dir / parquet.name, index=False)
+        frames.append(df)
+
+    if not frames:
+        raise SystemExit(f"No {folder} parquets found")
+    all_df = pd.concat(frames, ignore_index=True)
+
+    # Fail loud if the published frame somehow holds a non-allowlisted column,
+    # or if the source schema drifted away from the shares we expect.
+    extras = set(all_df.columns) - KEEP
+    if extras:
+        raise SystemExit(f"Leak: non-allowlisted columns survived in {folder}: {extras}")
+    if not {key_col, "agent", "pct_requests"} <= set(all_df.columns):
+        raise SystemExit(f"Source schema drift: expected share columns missing in {folder}")
+
+    print(f"✓ {folder}: {len(frames)} parquets → {out_dir}/  ({len(all_df)} rows)")
+    return all_df
+
+
+# ---------------------------- derive both granularities ----------------------
+
+monthly = derive("monthly", "month")
+daily = derive("daily", "day")
+
+# pct sanity check (already 0-100 in source)
+gs = monthly.groupby("month")["pct_requests"].sum()
+if not ((gs > 95) & (gs < 105)).all():
+    print(f"⚠ monthly pct_requests group sums look off: {gs.to_dict()}")
+
+latest = au.latest_month(monthly)
+leaders = au.top_agents(monthly, n=5)
+print(f"\nLatest month: {latest}")
+print(au.leaderboard_table(monthly).to_string(index=False))
+print(f"\nTrend cohort (top 5, {latest}): {leaders}")
+
+# ---------------------------- render PNGs (for tweet / card embedding) -------
+
+au.save_png(au.leaderboard_figure(monthly), OUT / "leaderboard.png")
+au.save_png(au.trend_figure(daily, agents=leaders), OUT / "trend.png")
+print(f"\n✓ {OUT/'leaderboard.png'}")
+print(f"✓ {OUT/'trend.png'}")
+
+# ---------------------------- push to the public dataset repo ----------------
+# Only when AGENT_USAGE_PUSH_REPO is set (on Jobs: -e AGENT_USAGE_PUSH_REPO=...).
+# Everything above stays local otherwise. One commit per run: derived parquets,
+# chart PNGs, the card, and this script + its module (the build is auditable
+# from the dataset repo itself).
+
+PUSH_REPO = os.environ.get("AGENT_USAGE_PUSH_REPO")
+if PUSH_REPO:
+    from huggingface_hub import CommitOperationAdd, HfApi
+
+    ops = []
+    for parquet in sorted(DATA.rglob("*.parquet")):
+        ops.append(CommitOperationAdd(str(parquet.relative_to(OUT)), str(parquet)))
+    for png in ("leaderboard.png", "trend.png"):
+        ops.append(CommitOperationAdd(f"assets/{png}", str(OUT / png)))
+    for script in ("build_local.py", "agent_usage.py"):
+        ops.append(CommitOperationAdd(script, str(HERE / script)))
+
+    # Card template → README.md with the freshness stamp filled in.
+    card = (
+        (HERE / "card" / "README.md")
+        .read_text()
+        .replace("{{LATEST_MONTH}}", latest)
+        .replace("{{GENERATED}}", str(date.today()))
+    )
+    ops.append(CommitOperationAdd("README.md", card.encode()))
+
+    api = HfApi()
+    # Created private: review the rendered card/viewer, then flip to public in
+    # settings (or api.update_repo_settings). exist_ok means later scheduled
+    # runs never touch visibility.
+    api.create_repo(PUSH_REPO, repo_type="dataset", private=True, exist_ok=True)
+    commit = api.create_commit(
+        repo_id=PUSH_REPO,
+        repo_type="dataset",
+        operations=ops,
+        commit_message=f"Update derived agent-usage shares (latest month: {latest})",
+    )
+    print(f"\n✓ pushed {len(ops)} files → {commit.commit_url}")
+else:
+    print("\n(no AGENT_USAGE_PUSH_REPO set — local build only, nothing pushed)")

data/daily/2026-04.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27288556544e8183d1b85e05df1a8b637a34f32c5c22ed539ec23c21b2873e2d
+size 7462

data/daily/2026-05.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1a25ce2f4d5ba51af1b0ed01806c5dcc5eff6f45570972850168a94a576162d
+size 10353

data/daily/2026-06.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8a0bb70be761f8cc9e0c1c53c9da81704d70948f6c43f16e41576e02246d212
+size 12064

data/monthly/2026-04.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34cf3e4bf845570d0d83e4a8a8cfcf1790389351c2e56bc1dd23db25ff224188
+size 3204

data/monthly/2026-05.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f461fad44165bee59c99583eda7bf669ce24b737089038152654cc461aa33de
+size 3251

data/monthly/2026-06.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7927534309233d1d631840aaae1f90b372fe1367efcf930bbbfb758e4e453ab4
+size 3442