Back to Blog
StreamingFast

Leveling Up Agentic Substreams Development: A Machine-Readable Registry, AI Coding Skills, and Agent Account Access

Substreams is StreamingFast's framework for indexing blockchain data: it lets developers extract, transform, and stream on-chain data in real time instead of building custom indexers from scratch. AI coding agents are increasingly the ones writing Substreams code, wiring up modules, and querying blockchain data on a developer's behalf. That shift changes what "good developer experience" means: it's no longer just documentation a human can skim, it's structured, machine-readable surfaces an agent can discover and act on autonomously. Over the past few months we've shipped a handful of changes aimed squarely at that audience, from a machine-readable registry, to skill packs that hand agents Substreams expertise directly, to agentic account access. Here's what's new.

What shipped:

  • A machine-readable OpenAPI spec for the substreams.dev registry, so agents can search and pull Substreams packages programmatically instead of scraping HTML.
  • Substreams Skills: 9 open-source knowledge packs to give your favorite coding agent built-in Substreams expertise.
  • Agentic access to thegraph.market, so agents can check usage, manage authentication via API keys, and monitor sink deployments without a human logging into a dashboard.

Substreams Skills for Claude Code, Cursor, and VS Code

Substreams Skills are open-source knowledge packs that give AI coding assistants deep Substreams expertise, out of the box. Install once, and your assistant — Claude Code, Cursor, or VS Code — applies Substreams best practices automatically instead of guessing at syntax or reinventing patterns. For the Rust modules especially, that's not a small thing: an agent that doesn't need to fight the borrow checker for twenty minutes before it compiles is doing genuinely more than autocomplete.

The pack currently ships as 9 skills covering the full workflow, from chain-specific decoding through production deployment:

  • Substreams Development — cross-chain manifests, module graphs, and protobuf schema design
  • Substreams Ethereum & Substreams Solana — chain-specific decoding (ABI codegen and event decoding on EVM; instruction and account parsing on Solana)
  • Substreams SQL — SQL database sinks for PostgreSQL and ClickHouse
  • Substreams Sink — consuming Substreams output in Go, JavaScript, Python, or Rust
  • Substreams Sink Deployment (Self-Managed) — running sinks yourself on your own infrastructure
  • Substreams Hosted Sink — deploying sinks on StreamingFast-hosted infrastructure instead of managing your own
  • The Graph Market API — natural-language billing, usage, and deployment management against thegraph.market's Portal API, plus the auth flow behind it
  • Substreams Testing — unit, integration, performance, and CI/CD testing

Install as a Claude Code plugin (claude plugin install substreams-dev@streamingfast-substreams) and skills stay current automatically; Cursor and VS Code 1.107+ support them too, via a local directory path.

The skills are also built to search the substreams.dev registry directly, so your agent reuses proven modules from StreamingFast, Pinax, and the teams behind the protocols themselves, rather than rebuilding a Substreams package from scratch. The result: faster builds, and pipelines that compose with what already exists instead of duplicating it. What used to take days — standing up a production blockchain data pipeline — now takes a plain-language prompt and a few minutes.

Agentic Access to thegraph.market

Agentic access to thegraph.market is now live, giving AI agents the ability to pull usage and API key data directly, rather than requiring a developer to log in and check a dashboard manually.

This closes a real gap: an agent could already discover and query Substreams packages, but it had no way to check whether you were about to hit a rate limit, which key to use, how a given job was billing against your account, or manage your Hosted Services deployments directly — scaling a sink, checking lag, or redeploying after a change. Now it can, without you leaving your terminal or chat window. One more step toward agentic workflows that run end-to-end, from writing code to managing the account and infrastructure behind it.

Your credentials stay out of it, too: the agent never sees or handles your password. Authentication happens entirely within thegraph.market; the agent acts on your behalf using your API key, but the password itself is never passed through or exposed to the agent.

In practice, that means you can ask your agent things like:

  • "What's our usage this month, and which service is driving most of it?" — the agent pulls usage broken down by API key and service, no dashboard required.
  • "Are we about to hit our rate limit, and should we upgrade?" — it checks current usage against your plan and gives you a straight answer before a job fails mid-run.
  • "Is my sink still running, and what's its lag?" — it checks deployment status and head-block lag directly, and can scale or redeploy it if you ask.

Each of those used to mean logging into thegraph.market yourself. Now they're a prompt.

A Machine-Readable substreams.dev Registry

The substreams.dev registry now publishes a full OpenAPI specification, making it easier for AI coding agents to crawl, parse, and reason about Substreams packages programmatically. The spec is available at substreams.dev/v1/registry/openapi.yaml and describes every registry endpoint in a structured format a coding agent can read directly.

Instead of scraping HTML or guessing at request shapes, an agent can pull the spec once and know exactly how to search for existing Substreams packages, inspect their modules, and pull down the artifacts it needs to build on top of them.

For example, an agent can query the registry directly:

GET https://substreams.dev/v1/registry/packages?query=uniswap&network=mainnet

and get back structured results it can act on immediately, no HTML parsing required:

{
  "packages": [
    {
      "name": "Uniswap v3",
      "slug": "uniswap-v3",
      "organization": { "name": "Pinax", "slug": "pinax" },
      "network": "mainnet",
      "latestVersion": "v0.1.0",
      "downloads": 1234,
      "spkg": "https://substreams.dev/pinax/uniswap-v3/v0.1.0/uniswap-v3-v0.1.0.spkg",
      "reference": "uniswap-v3@v0.1.0"
    }
  ],
  "hasMore": false
}

The response is deliberately split into two ways to reference the same package: spkg is the full URL an agent passes straight into substreams run <spkg> <module> to execute it, while reference is the short, human-readable slug@version form it uses when showing a command to you. An agent can go from "does a Uniswap package already exist for mainnet?" to running it in a single round trip.

In practice, this means when you ask an agent to find a Substreams package for a given chain or use case, or to check whether one already exists before writing a new one, it has a reliable, structured path to the answer instead of falling back on stale training data.

Common Questions, Now Doing Double Duty

The Common Questions section on this blog was built for fast, direct answers, and it turns out that format is exactly what AI agents need too. It was originally designed to help human developers get quick answers to the things that come up again and again: how modules connect, what a manifest needs, how sinks work.

Well-scoped, direct Q&A is far easier for an agent to retrieve and act on than a long-form tutorial. As agents increasingly do the first pass of research before writing code, that section is doing double duty: pointing both new developers and their AI agents toward the right patterns instead of guessed-at ones. It's a small example of a bigger principle: content structured to answer a specific question well serves people and agents equally.

Taken together, these changes point at the same idea: Substreams development is getting faster not because the underlying data pipeline changed, but because the surfaces around it — the registry, the account layer, the documentation — are now built for both people and the agents working alongside them.

Ready to put an AI agent to work on your own Substreams project? Install Substreams Skills to give your assistant Substreams expertise out of the box, then have it browse the substreams.dev registry to find an existing package for your chain, or check our Common Questions for the patterns your agent needs to get started.