hfpaper: why every AI agent needs a research librarian

I was feeding my son Atlas banana yogurt when I saw Clem Delangue announce that Hugging Face had just made it easier for agents to read research papers. A few tweets down, someone replied: "This needs to be a CLI or MCP."

So I told my agents to build it. 45 minutes later, hfpaper was live.

The problem nobody talks about

AI agents are increasingly asked to do research-grade work. "Read this paper." "What's the state of the art?" "Find me the model that implements this approach."

But they have no good way to access papers. They fetch raw HTML from arXiv, get mangled LaTeX, lose figures, miss metadata. They don't know which papers have model checkpoints or datasets. They can't cite what they read.

Hugging Face built the API. They published a skill that teaches agents how to use it. But the skill is a prompt — it teaches one agent in one session how to make curl calls. It's not composable. It's not installable. It doesn't work outside the context window it lives in.

What hfpaper does

A single Go binary wrapping the entire HF Papers API. 7.8MB. Zero dependencies. --json for agents, --table for humans.

Install however you want:

npx hfpaper search "transformers"
brew install zakelfassi/tap/hfpaper
go install github.com/zakelfassi/hfpaper@latest

Or grab a binary from Releases.

The MCP angle

The real feature: hfpaper mcp starts a Model Context Protocol server. Seven tools, stdio transport. Drop this in your Claude or Cursor config:

{
  "mcpServers": {
    "hfpaper": {
      "command": "hfpaper",
      "args": ["mcp"]
    }
  }
}

Your agent can now search and read papers natively. Not through a prompt that teaches it curl. Through a compiled tool that speaks JSON-RPC. The difference between giving your agent a textbook and giving it a librarian.

The 45-minute build

I was feeding Atlas the entire time.

What this actually unlocks

A CLI that reads papers sounds small. It isn't. The moment an agent can search, read, and cite research natively, the workflows that open up are the ones nobody's built yet.

Daily research pulse. hfpaper daily --trending piped into a cron that filters by your interests — multimodal reasoning, RL from human feedback, whatever your stack touches. Every morning, your agent tells you what moved in the fields you care about. Not a newsletter someone else curated. A digest tuned to your context, built from the primary sources.

Paper-to-experiment pipeline. Your agent reads a paper, identifies the architecture, checks if the model checkpoint exists on HF (hfpaper models <id>), and scaffolds a reproduction. Projects like Paper2Code and AutoReproduce have shown this pipeline works — but they require custom infrastructure. hfpaper is the first step: give the agent the paper. The rest is prompt engineering.

Research-informed building. "What's the current state of the art for X?" is a question every builder asks and every agent fumbles. With MCP wired in, the question becomes a tool call. Your agent searches, reads the abstract, pulls the related models, and answers with citations — not hallucinated references to papers that don't exist, but real links to real work.

Competitive intelligence. What papers are trending in your space today? Which ones have model checkpoints already? Which ones have zero implementations — meaning the gap between paper and product is still open? That's alpha, and it refreshes daily.

The common thread: we're moving from building to discovery. The build step is collapsing toward zero. The hard part is knowing what to build next — and that answer lives in the research frontier. The agent that can read papers is the agent that can find the next thing worth building.

We're at the "Google yet to be born" era of intelligence infrastructure. The papers exist. The models exist. The gap is the connective tissue between knowing and doing. hfpaper is one strand of that tissue.

The meta-question

At roughly the same time I was building hfpaper, Muratcan Koylan — the person who tweeted "this needs a CLI" — was building his own internal skill called context-research that does overlapping work. His skill orchestrates parallel searches, triages by relevance, fetches full content as markdown. Sound familiar?

Two people. Same impulse. Same day. No awareness of each other until after both shipped.

When building takes 45 minutes, duplication becomes the default failure mode. Not because people are careless — because there's no surface where work-in-progress is visible before it's finished. GitHub shows you code after it's pushed. Twitter shows you launches after they ship. Nothing shows you the intent to build while it's still forming.

That's what I'm building with Gabl.us — a communication platform where the unit isn't the avatar, it's the project. Stories scoped to what you're working on. Private by default. Visible to the people who'd want to join. Not a feed of finished products. Not a social network. A place where you can see that someone already started the thing you're about to start, before you both waste 45 minutes arriving at the same binary.

The world doesn't need faster building. It needs fewer parallel builds. The infrastructure for that doesn't exist yet. But the pressure is building — 45 minutes at a time.

hfpaper.zakelfassi.com · GitHub · npm