RESERVE v1.2.2: Opening the Official Workflow Catalog

RESERVE v1.2.2 opens the first public window into the official RESERVE workflow catalog.

The previous release, v1.2.1, established an important architectural boundary: the official reserve-workflows collection would live separately from local workflows and examples, and the CLI would access that collection through the RESERVE workflow API rather than depending directly on GitHub, object storage, or another distribution mechanism.

v1.2.2 puts that boundary to work

For the first time, RESERVE can browse the official workflow catalog and retrieve versioned workflow definitions through the permanent API at:

https://api.reservecli.dev/v1

This is intentionally a read-only preview.

RESERVE does not install remote workflows in v1.2.2. It does not publish them, update them, authenticate private repositories, or execute downloaded pipeline content.

The goal of this release is narrower: make the official catalog visible through the CLI, prove the API boundary, and establish a foundation that later releases can build on without weakening the local-first workflow model.

Browsing the Official Catalog

The most visible addition is:

reserve workflow browse

This command lets users inspect the official workflow catalog directly from RESERVE.

The complete catalog can be browsed from the CLI, or the results can be narrowed to a particular collection.

Catalog output follows RESERVE’s existing output conventions. The normal command-line experience uses a readable table, while JSON output is available for tools, agents, scripts, and other programmatic consumers.

This is the first point at which the reserve-workflows catalog becomes something an installed RESERVE client can discover rather than merely an architectural concept.

In v1.2.1, the official repository had a name and an API boundary.

In v1.2.2, that boundary has something useful on the other side.

Retrieving an Official Workflow

Browsing tells you what exists. The second new command lets you inspect the workflow itself:

reserve workflow get [version]

RESERVE can retrieve an official workflow definition from the API, including a specific version when requested.

The default output is the raw workflow YAML.

That choice is deliberate. A workflow is ultimately a portable document, and when a user asks RESERVE to retrieve one, the most useful default is the document itself rather than an additional presentation layer around it.

For programmatic consumers, JSON envelopes are also supported.

Together, browse and get provide the first complete read path from the RESERVE CLI into the official workflow catalog:

reserve workflow browse

Find a workflow.

reserve workflow get ...

Retrieve its definition and then inspect it. Nothing is installed. Opening the door to this future ecosystem is a big thing and v1.2.2 deliberately takes a small step.

The preview does not include:

  • remote workflow installation or updates;
  • workflow publishing;
  • repository management;
  • private repository authentication;
  • ratings or search;
  • remote execution;
  • user enrollment.

The catalog is available for inspection, but the CLI does not turn retrieved content into executable behavior. This keeps the new network boundary small enough to reason about. A remote workflow definition can be useful without automatically being trusted. RESERVE v1.2.2 treats those as separate concerns.

Retrieval Is Not Execution

That distinction is especially important for pipeline workflows.

RESERVE v1.2.2 never executes workflow pipeline content.

workflow render 

does not invoke Bash or another shell. Rendered pipeline stages remain descriptive output intended for operator or agent review.

They should not be interpreted as a promise that arbitrary pipeline content is portable, deterministic, or safe to execute across platforms. From a security perspective, this is critical. Repository-style references are also constrained so that they cannot traverse or escape the configured workflow root, including through symlinks. These restrictions are not temporary obstacles to work around. They reflect the security model RESERVE is trying to preserve as workflows become increasingly shareable.

Execution may come later, but only after its semantics are defined well enough to make it secure, deterministic, and cross-platform. Until then, remote workflow discovery and remote workflow execution remain intentionally separate capabilities.

# Browse the official workflow catalog
reserve workflow browse

# Browse one collection
reserve workflow browse inflation

# Retrieve the latest CPI workflow
reserve workflow get inflation cpi-history

# Retrieve a specific immutable version
reserve workflow get inflation cpi-history 1.0.0

# Retrieve workflow metadata as JSON
reserve workflow get inflation cpi-history 1.0.0 --format json

The API Is the Contract

One of the most important parts of v1.2.2 may be something users never have to think about.

Official workflow reads go through:

https://api.reservecli.dev/v1

The CLI does not expose GitHub, R2, or another storage provider as the repository contract.

That follows directly from the architecture introduced in v1.2.1.

The official workflow collection may be authored in one place, indexed somewhere else, and distributed through infrastructure that changes over time. None of those choices should require users to learn a new workflow model or force the CLI to encode a particular hosting provider’s repository layout.

The RESERVE API is the stable boundary.

v1.2.2 includes typed internal registry client support for catalog, collection, and artifact reads so that this separation exists in the implementation as well as in the documentation.

That gives future releases room to evolve the service without making storage infrastructure part of RESERVE’s public CLI contract.

A Preview of a Larger Service Boundary

The API in v1.2.2 is deliberately public and read-only.

It is not yet RESERVE’s authenticated service model.

In particular, the preview does not use a FRED API key as RESERVE authentication.

That distinction matters because a FRED API key identifies access to FRED. It should not quietly become a general-purpose credential for RESERVE services.

The next stage of the service boundary is planned around explicit RESERVE identity and authentication: verified-email enrollment, one-time FRED-key validation, RESERVE token issuance, and authenticated API enforcement.

Those capabilities remain v1.2.3 work.

Keeping them out of v1.2.2 lets this release answer a simpler question first:

Can RESERVE expose a stable, useful, provider-independent read path to the official workflow catalog?

Now it can.

Local Workflows Still Stay Local

The addition of an official catalog does not change the role of RESERVE’s existing local workflow system.

The distinction established in v1.2.1 remains:

examples/workflows/

Educational examples shipped with the source tree.

~/.reserve/workflows/personal/

User-created and locally managed workflows.

reserve-workflows/

The curated official workflow collection.

RESERVE workflow API

The distribution boundary through which the CLI accesses official workflow content.

v1.2.2 connects the final two pieces for read operations.

It does not collapse them into the local workflow model.

Users can discover and retrieve official workflows while local authoring remains its own concern. That separation gives RESERVE room to introduce installation and repository management deliberately rather than making every remote artifact implicitly local.

# List locally available workflows
reserve workflow list

# Show a normalized workflow document
reserve workflow show examples/workflows/simple-observation.yaml

# Inspect required runtime inputs
reserve workflow contract examples/workflows/parameterized-workflow.yaml

# Validate a workflow
reserve workflow validate examples/workflows/parameterized-workflow.yaml

# Render a copy-ready pipeline without executing it
reserve workflow render examples/workflows/parameterized-workflow.yaml 2015-01-01 2024-12-31

Designed for People and Tools

The new commands also continue a pattern that is becoming increasingly important for RESERVE: CLI output should work for both human operators and programmatic consumers.

Catalog browsing supports the familiar table view for interactive use and JSON for structured consumption.

Workflow retrieval defaults to raw YAML because that is the natural representation for a workflow definition, while JSON envelopes are available when metadata and structured integration matter.

This makes the preview useful beyond an interactive terminal.

An operator can browse the catalog.

A script can consume the catalog as JSON.

An agent can retrieve a workflow definition for inspection.

And in every case, retrieval remains retrieval. RESERVE does not silently turn inspection into execution.

Verified Before Release

The v1.2.2 release has been tested across the CLI and internal packages.

make test passes, as does:

go test ./cmd ./internal/… ./tests

Registry client tests cover catalog reads, collection reads, versioned artifact retrieval, and bearer-header behavior.

go vet ./… also passes.

The release distribution build produces the expected platform archives and SHA256SUMS, with release documentation and manifests updated for v1.2.2.

From Boundary to Interface

v1.2.1 was about deciding where things belong.

v1.2.2 is about making one of those boundaries useful.

The official reserve-workflows collection is no longer only a future repository described by the architecture. It is now discoverable through the RESERVE CLI.

But the scope remains intentionally constrained.

  • Browse.
  • Retrieve.
  • Inspect.
  • Do not execute.
  • Do not assume trust.
  • Do not couple the CLI to the infrastructure behind the API.
  • Those constraints give RESERVE a much stronger foundation for what comes next.

Future releases can add identity, authenticated access, installation, private repositories, publishing, and eventually carefully defined execution semantics on top of an API boundary that already exists and a catalog model that is already usable.

RESERVE v1.2.2 is the first public connection between the CLI and the official workflow ecosystem.

It opens the catalog without opening the door to everything at once.

Why JSONL Matters for FRED Data

When most people think about working with FRED data, they think in terms of CSV files or API JSON responses. CSV files make immediate sense to the desktop economist: download the series, open it in Excel, chart it, regress it, annotate it, and move on. Plain JSON serves a different audience. It is the natural format for applications, APIs, and software systems that need structured data with fields, arrays, and metadata. Both formats are familiar, both are widely supported, and both are perfectly adequate for small-scale analysis. But once you begin building downstream pipelines around economic observations — particularly pipelines that transform, stream, enrich, or continuously ingest data — the limitations of those formats begin to show.

This is where JSONL becomes interesting.

What is JSONL?

JSONL stands for JSON Lines.

Instead of storing all records inside a single JSON array, JSONL stores one JSON object per line.

For example:

{"date":"2024-01-01","value":"100.2"}
{"date":"2024-02-01","value":"101.1"}
{"date":"2024-03-01","value":"101.8"}

Each line is independently valid JSON.

That small design difference has major implications for data engineering workflows.

JSON vs JSONL

Traditional JSON usually looks like this:

{
  "observations": [
    {"date":"2024-01-01","value":"100.2"},
    {"date":"2024-02-01","value":"101.1"},
    {"date":"2024-03-01","value":"101.8"}
  ]
}

Traditional JSON encourages you to think in terms of documents. A FRED response becomes one large object containing metadata, arrays, nested structures, and observation collections. Before a downstream process can begin its work, the entire payload typically needs to be materialized in memory and parsed as a complete unit.

JSONL encourages a different mental model. Instead of one document containing observations, the observations themselves become the primary unit of computation. Each line can be read independently, transformed independently, validated independently, and streamed independently. The data stops behaving like a static export and starts behaving like a sequence of economic events flowing through a pipeline.

That distinction matters enormously for time-series systems.

Economic observations are naturally append-oriented. New CPI values arrive. New unemployment figures arrive. GDP revisions arrive. Rarely do we need to reinterpret the entire historical universe every time a new observation appears. More commonly, we want to process the newest data incrementally while preserving provenance and transformation history downstream.

CSV works extremely well right up until the moment your workflow becomes more complicated than a spreadsheet. A single economic series with a date column and a value column is simple. But once you start combining multiple series, revision histories, release metadata, transformations, or provenance tracking, the format starts showing its age. Important context often ends up scattered across filenames, sidecar documents, README notes, or pipeline assumptions rather than traveling with the observations themselves.

Traditional JSON solves some of those problems, but introduces another. The data becomes hierarchical and application-centric rather than stream-centric. Appending a single new observation often means rewriting an entire array. Distributed processing becomes less elegant. Line-oriented tooling becomes harder to leverage.

JSONL occupies a remarkably useful middle ground. It preserves the self-describing nature of JSON while remaining operationally compatible with streaming systems, append-only workflows, Unix pipelines, and distributed analytical tooling.

That alignment becomes especially important inside RESERVE.

Within RESERVE, FRED observations are not treated merely as downloadable datasets. They are treated as composable records that can move through transformation pipelines. Once observations are emitted as JSONL, the output becomes naturally compatible with downstream operators:

reserve fred observations CPIAUCSL --format jsonl

At that point, transforms stop feeling like post-processing steps attached to static files and begin behaving more like streaming operators acting on a flow of economic observations.

A rolling average transform no longer needs to conceptualize itself as “opening a file.” It can instead consume observations incrementally as they arrive:

reserve fred observations FEDFUNDS --format jsonl \
  | reserve transform moving-average --window 12

This is ultimately why JSONL matters for FRED data. The format aligns with the actual shape of economic time-series workflows. Observations arrive sequentially. Pipelines process sequentially. Transformations operate sequentially. JSONL simply removes unnecessary structural friction between the data and the systems operating on it.

Consumers as First Class Citizens

RESERVE was designed and developed to democratize access to FRED data. One key design goal was to treat humans, other programs, and LLM-based agents as first-class consumers.

RESERVE’s tabular formats and charting functions target human consumers. CSV targets desktop tools and relational data stores. JSON targets API-driven applications and LLMs, while JSONL caters to data pipelines and streaming-oriented applications.

A naysayer might ask, “So what? Any program or script can reformat data!”

There is an important nuance.

Accessing FRED data requires consumers to adhere to the usage requirements of the underlying sources. A FRED source generally falls into one of three categories:

  • Public Domain: Citation Requested
  • Copyrighted: Citation Required
  • Copyrighted: Contact Source (Permission is Required)

As a software program, RESERVE checks source-usage requirements during retrieval and carries the appropriate disclosure information throughout its processing, including into its various output formats.

In the example below, GDP is a public-domain data series for which citation is requested:

reserve obs latest gdp --format jsonl
{"series_id":"GDP","date":"2026-04-01","value":32486.066,"value_raw":"32486.066","citation_text":"Source: Bureau of Economic Analysis via FRED"}

Compliance with FRED’s source-usage requirements involves more than using a standard library to flip data from one output format to another. The disclosure must remain semantically attached to the data as it moves through RESERVE’s processing pipeline and into the format requested by the consumer.

This behavior was deliberately architected into RESERVE. Its validation is also part of the automated test suite and is revalidated with every release.

Summary

Modern software can generally convert data back and forth between formats. But not having the right format at the point of consumption creates inefficiencies, unnecessary processing, and performance headwinds. This is particularly relevant when working with large datasets, such as those potentially delivered by the FRED API.

RESERVE treats all consumers—and the formats they consume—as first-class citizens. Humans can work with tables and charts. Desktop tools and databases can consume CSV. Applications and LLMs can consume JSON. Data pipelines can consume JSONL.

Moreover, RESERVE recognizes that the format is only part of the contract. Source disclosure and usage requirements must travel with the data. By preserving that information across formats, RESERVE delivers data that is not only convenient to consume, but also carries the context necessary to use it responsibly.

RESERVE v1.2.1: Putting the Workflow Boundaries in Place

RESERVE v1.2.1 is a deliberately focused release.

After the substantial workflow foundation introduced in v1.2.0, this release takes the next practical step: establishing where workflows belong, clarifying the boundaries between different kinds of workflow repositories, and adding a small set of examples that make the existing workflow system easier to understand.

It is a plumbing and documentation release.

There are no new remote workflow commands in v1.2.1. No catalog browsing, installation, publishing, private repository authentication, or remote execution has been added. Instead, the release prepares the project for those capabilities without prematurely building them.

Examples Are Examples

RESERVE now includes four curated workflow examples under:

examples/workflows/
├── simple-observation.yaml
├── transform-pipeline.yaml
├── multi-series-analysis.yaml
├── parameterized-workflow.yaml
└── README.md

Together, these examples demonstrate several parts of the workflow model:

  • a simple single-series observation;
  • a transformation pipeline;
  • multi-series analysis;
  • runtime parameters and workflow contracts.

They are intentionally readable and modest. Their purpose is to show workflow syntax and CLI capabilities, not to serve as production-grade economic research.

The examples also establish an important rule:

examples/workflows/ is educational source-tree content. It is not the official RESERVE workflow catalog.

That distinction matters as the project grows. Examples may demonstrate simplified data, unusual features, or authoring patterns that do not belong in a curated public collection.

A Clearer Workflow Ecosystem

RESERVE workflows now have clearly defined homes:

examples/workflows/
    Educational examples shipped with the source tree.

~/.reserve/workflows/personal/
    User-created and locally installed workflows.

reserve-workflows/
    The future canonical, curated public workflow collection.

Private repositories/
    Future user- or organization-controlled collections.

RESERVE workflow API/
    The future distribution boundary between the CLI and repositories.

The official repository is named reserve-workflows.

That name now exists as a first-class internal repository descriptor rather than as a collection of hard-coded GitHub URLs or storage-specific assumptions. The CLI’s future repository operations can depend on the concept of an official repository while remaining independent of how that repository is authored, published, indexed, or stored.

GitHub may be the source of truth for the curated workflow collection. A cloud-based API and supporting distribution services may eventually provide access to that collection. Those implementation details should remain behind the RESERVE workflow API boundary.

The Official Repository Boundary

The internal official repository descriptor identifies:

id:       official
name:     reserve-workflows
type:     official
endpoint: https://api.reservecli.dev/v1

This does not yet enable remote workflow operations. It simply establishes the abstraction that future releases can build upon.

The initial API boundary is intentionally small:

GET /workflows
GET /workflows/{id}
GET /workflows/{id}/{version}

The exact service implementation can evolve later without requiring the CLI to understand GitHub repository layouts, static object paths, R2 buckets, or other infrastructure details.

What Users Will Notice

For most installed users, v1.2.1 is intentionally quiet.

The existing workflow commands continue to work as before:

reserve workflow create
reserve workflow list
reserve workflow show
reserve workflow edit
reserve workflow remove
reserve workflow validate
reserve workflow render
reserve workflow contract

The release does not add commands such as:

reserve workflow browse
reserve workflow install
reserve workflow update
reserve workflow publish

The new examples are shipped in the RESERVE source repository for developers and contributors. They are not automatically copied into a user’s ~/.reserve/workflows/ directory, and they are not presented as the official catalog.

That keeps the local-first behavior of RESERVE unchanged while giving workflow authors clearer reference material.

Go 1.27.1

RESERVE v1.2.1 also updates the supported release toolchain note to Go 1.27.1.

This is a small implementation detail, but documenting the toolchain used for the release improves reproducibility and gives users and maintainers a clearer baseline for future builds.

A Small Release With a Long-Term Purpose

The goal of v1.2.1 is not to make the workflow system larger. It is to make its boundaries harder to misunderstand.

Examples should remain examples.

Personal workflows should remain local.

The official catalog should have its own repository.

Private repositories should arrive only when their authentication and authorization model is ready.

And the CLI should communicate with repositories through a stable RESERVE abstraction rather than through infrastructure-specific knowledge.

That gives future releases room to add official workflow browsing and installation without turning the local workflow foundation into a tangle of special cases.

RESERVE v1.2.1 establishes the physical and architectural boundaries of that ecosystem, while keeping the user-facing CLI focused, local, and predictable.

What Moved the 10-Year? Introducing Workflows in RESERVE 1.2.0

Economic analysis rarely consists of just one data series. In graphical user interface (GUI) software, that often means the story requires more than one chart. At the command line, it usually requires more than one command.

RESERVE 1.2.0 is a foundational release that introduces workflows: portable definitions for creating, saving, inspecting, and sharing complex economic analyses.

Workflows Explained

RESERVE power users frequently pipe together commands for data retrieval, transformation, visualization, and analysis. They also understand which economic series must be examined together to explain a macroeconomic concept.

A command can retrieve the 10-year Treasury yield. Explaining why that yield moved requires considerably more context. The analyst may also need real interest rates, inflation expectations, the term premium, shorter-term Treasury yields, Federal Reserve policy, and broader indicators of inflation, employment, and economic growth.

The new workflow command family provides a way to package that knowledge. A workflow can describe:

  • the economic question being examined;
  • the FRED series required for the analysis;
  • the ordered RESERVE commands that make up the analysis;
  • any values the operator must provide;
  • the expected outputs, runtime, and network requirements; and
  • the supporting documentation and authorship.

RESERVE 1.2.0 introduces the following workflow commands:

reserve workflow create <FILE|REF>
reserve workflow list
reserve workflow show <FILE|REF>
reserve workflow edit <FILE|REF>
reserve workflow validate <FILE|REF...>
reserve workflow contract <FILE|REF>
reserve workflow render <FILE|REF> [ARGS...]
reserve workflow remove <FILE|REF>

Together, these commands support the workflow-authoring journey:

create -> edit -> validate -> inspect contract -> render

In this release, workflows are stored locally as readable YAML documents. Those documents can be shared directly, placed under source control, or organized under repository and collection namespaces.

personal/interest-rates/ten-year-treasury-drivers

The name has three parts:

personal                   repository namespace
interest-rates             collection
ten-year-treasury-drivers  workflow

Today, personal identifies a locally authored workflow. The naming model also lays the foundation for future sources such as official, community, education, and private, where institutions and other publishers could distribute trusted workflow collections.

Repository search, installation, and publishing are not part of RESERVE 1.2.0. This release establishes the local workflow model and the naming conventions that those future capabilities can build upon.

The Treasury Yield Example

Headlines over the past several weeks have been dominated by renewed volatility in longer-term Treasury yields. The 30-year Treasury yield climbed to levels not seen in nearly two decades before retreating, while the 10-year yield repeatedly moved through the upper portion of its recent range.

But observing that the 10-year Treasury yield moved does not explain why it moved.

That question requires us to examine several related forces:

  • Did real interest rates rise?
  • Did market-implied inflation expectations change?
  • Did investors demand more compensation for holding longer-duration securities?
  • Did expectations for Federal Reserve policy shift?
  • Did the shape of the Treasury yield curve change?
  • Did new inflation, labor-market, or economic-growth data alter the outlook?

This is exactly the kind of question a workflow is designed to explore.

Rather than rebuilding the analysis each time Treasury yields move, we can define the analytical method once, give it a durable name, and render it for any requested date range:

reserve workflow contract ten-year-treasury-drivers
reserve workflow render ten-year-treasury-drivers 2026-07-01 2026-08-27

The workflow remains the same. Only the period being investigated changes.

Creating the Workflow

Rather than rebuilding the analysis each time Treasury yields move, we can define the analytical method once and give it a durable name.

We will begin by creating an interest-rates collection in our personal repository with a treasury drivers workflow:

reserve workflow create personal/interest-rates/ten-year-treasury-drivers

This creates the following three-part identity:

personal repository
interest-rates collection
ten-year-treasury-drivers workflow

The personal namespace tells us that this is a locally authored workflow. In the future, the same analytical method might be published under a name such as:

official/interest-rates/ten-year-treasury-drivers

The repository name would identify its source and owner without changing how the workflow itself is used.

We can open the new definition in our configured editor:

reserve workflow edit personal/interest-rates/ten-year-treasury-drivers

For this analysis, the workflow contains six FRED series:

RoleFRED series
Nominal 10-year Treasury yieldDGS10
Real 10-year Treasury yieldDFII10
10-year breakeven inflationT10YIE
2-year Treasury yieldDGS2
10-year minus 2-year yield-curve slopeT10Y2Y
Model-estimated 10-year term premiumTHREEFYTP10

The resulting workflow definition is:

workflow:
  title: What Moved the 10-Year?
  summary: Compare market components and policy signals behind moves in the 10-year Treasury yield.

  difficulty: Intermediate
  estimated_runtime: 20 seconds

  categories:
    - interest-rates
    - treasury
    - monetary-policy

  concepts:
    - 10-Year Treasury
    - Real Yields
    - Breakeven Inflation
    - Term Premium
    - Yield Curve
    - Federal Reserve

  outputs:
    - table

  requires_network: true
  reserve_version: ">=1.2"

  author: Derick Schaefer
  documentation: README.md

  contract:
    - label: start date
      format: YYYY-MM-DD
      sample: 2026-07-01
      description: First date in the Treasury-market comparison window.
    - label: end date
      format: YYYY-MM-DD
      sample: 2026-08-27
      description: Final date in the Treasury-market comparison window.

  pipeline:
    - reserve obs get DGS10 DFII10 T10YIE DGS2 T10Y2Y THREEFYTP10 --start @1 --end @2 --format jsonl --quiet
    - reserve analyze summary --by-series

Each item under pipeline represents one command stage. When rendered, RESERVE joins those stages with the pipe operator.

Before using the workflow, we validate its YAML structure, input contract, namespace, and RESERVE version requirement:

reserve workflow validate personal/interest-rates/ten-year-treasury-drivers
✓ Validated 1 workflow file(s)

Inspecting the Contract

The workflow requires a start date and an end date. We can inspect those requirements without reading the YAML directly:

reserve workflow contract ten-year-treasury-drivers
personal/interest-rates/ten-year-treasury-drivers contract:
  @1 = start date
    format: YYYY-MM-DD
    sample: 2026-07-01
    description: First date in the Treasury-market comparison window.
  @2 = end date
    format: YYYY-MM-DD
    sample: 2026-08-27
    description: Final date in the Treasury-market comparison window.

The first value supplied to render replaces @1. The second replaces @2.

Rendering the Analysis

We can now render the workflow for the period we want to investigate:

reserve workflow render ten-year-treasury-drivers 2026-07-01 2026-08-27

reserve obs get DGS10 DFII10 T10YIE DGS2 T10Y2Y THREEFYTP10 --start '2026-07-01' --end '2026-08-27' --format jsonl --quiet | reserve analyze summary --by-series

RESERVE does not execute this command. The operator or agent receives the fully resolved pipeline and can review it before deciding whether to invoke it.

If invoked, the pipeline retrieves all six series over the same date window and produces one descriptive summary per series. That allows us to compare the nominal yield with movements in real yields, breakeven inflation, shorter-term rates, the yield-curve slope, and the model-estimated term premium.

This is descriptive analysis rather than a formal causal decomposition. The series also have different release calendars, so their final available observations and observation counts may differ slightly.

The workflow remains the same. Only the period being investigated changes:

reserve workflow render ten-year-treasury-drivers 2026-08-01 2026-08-27

That is the central value of a RESERVE workflow: the analytical method becomes durable, inspectable, and reusable while its runtime inputs remain flexible.

$ ./reserve obs get DGS10 DFII10 T10YIE DGS2 T10Y2Y THREEFYTP10 --start '2026-07-01' --end '2026-08-27' --format jsonl --quiet | reserve analyze summary --by-series
+-------------+-------+--------+--------+--------+--------+--------+--------+------------+
| SERIES      | COUNT | MISS   | MEAN   | STD    | MIN    | MEDIAN | MAX    | CHANGE PCT |
+-------------+-------+--------+--------+--------+--------+--------+--------+------------+
| DFII10      | 42    | 1|2.4% | 2.3720 | 0.0567 | 2.2400 | 2.3900 | 2.4700 | 4.00%      |
| DGS10       | 42    | 1|2.4% | 4.6361 | 0.0713 | 4.4800 | 4.6500 | 4.7500 | 4.24%      |
| DGS2        | 42    | 1|2.4% | 4.2137 | 0.0538 | 4.1300 | 4.2000 | 4.3700 | 0.72%      |
| T10Y2Y      | 42    | 1|2.4% | 0.4224 | 0.0606 | 0.3100 | 0.4400 | 0.5300 | 51.61%     |
| T10YIE      | 42    | 1|2.4% | 2.2641 | 0.0353 | 2.2000 | 2.2600 | 2.3400 | 4.48%      |
| THREEFYTP10 | 38    | 1|2.6% | 0.8122 | 0.0397 | 0.7216 | 0.8216 | 0.8682 | 20.32%     |
+-------------+-------+--------+--------+--------+--------+--------+--------+------------+

Sources by series:
- DFII10: Board of Governors via FRED
- DGS10: Board of Governors via FRED
- DGS2: Board of Governors via FRED
- T10Y2Y: St. Louis Fed via FRED
- T10YIE: St. Louis Fed via FRED
- THREEFYTP10: Board of Governors via FRED

What does this data tell us?

SeriesApprox. startApprox. endMove
10Y nominal (DGS10)4.48%4.67%+19 bp
10Y real (DFII10)2.25%2.34%+9 bp
10Y breakeven (T10YIE)2.23%2.33%+10 bp
2Y (DGS2)4.17%4.20%+3 bp
10Y–2Y (T10Y2Y)0.31%0.47%+16 bp
10Y term premium (THREEFYTP10)~0.72%~0.87%~+15 bp

The 10-year Treasury yield rose roughly 19 bp from early July through August 27. The move was split almost evenly between higher real yields (~9 bp) and higher inflation compensation (~10 bp). Because the 2-year moved only ~3 bp while 2s10s steepened ~16 bp, the selloff was concentrated at the long end rather than being primarily a near-term Fed repricing. A roughly 15 bp increase in the Fed’s 10-year term-premium estimate further suggests that rising term premium was an important component of the move.

RESERVE v1.2.0: Introducing Workflows

One of the recurring goals in RESERVE development has been making sophisticated economic analysis easier to create, understand, and repeat.

As the project has grown, users have increasingly combined data retrieval, transformation, analysis, and visualization commands into pipelines. These pipelines are one of the CLI’s greatest strengths, but they also introduce a practical challenge: a useful analysis often needs to be reconstructed each time it is performed. For agentic users of RESERVE, that translates to avoidable token consumption.

RESERVE 1.2.0 introduces a foundation for solving that problem.

The release adds workflows, a content-first system for creating, documenting, validating, and sharing reusable economic analyses.

A workflow can describe the purpose of an analysis, the economic concepts it covers, the inputs it requires, and the RESERVE pipeline used to perform it. Static workflows can represent fixed analyses with no runtime inputs, while dynamic workflows can accept ordered values such as a start date, end date, country, series, or comparison period.

Version 1.2.0 does not attempt to solve every part of workflow distribution and execution. Instead, it establishes the document format, command model, filesystem layout, validation rules, and safety boundaries upon which the broader workflow ecosystem can be built.

Introducing the Workflow Command

The new workflow command family provides the tools needed to author and inspect reusable analyses:

reserve workflow create
reserve workflow validate
reserve workflow list
reserve workflow show
reserve workflow edit
reserve workflow remove
reserve workflow contract
reserve workflow render

The command model follows RESERVE’s noun-verb convention. Workflow is the object being managed, while commands such as create, validate, and render describe the action being performed.

A new collection can be created with:

reserve workflow create personal/economic-growth

A workflow can then be added to that collection:

reserve workflow create personal/economic-growth/gdp-summary

RESERVE creates a collection-oriented directory structure:

~/.reserve/workflows/
  personal/
    economic-growth/
      collection.yaml
      README.md
      workflows/
        gdp-summary.yaml

The collection README is a normal repository artifact. It can explain the purpose of the collection, document its workflows, and travel with the collection when it is distributed through Git or another repository service. RESERVE scaffolds the initial README but never overwrites existing documentation.

Static and Dynamic Workflows

Not every analysis requires user input.

A static workflow can define a fixed pipeline that is rendered the same way every time. This is useful for established dashboards, recurring reports, classroom demonstrations, or analyses tied to a specific series and period.

Dynamic workflows add an ordered runtime contract.

For example, a GDP summary workflow might declare two inputs:

contract:
  - label: start date
    format: YYYY-MM-DD
    sample: 2020-01-01
    description: First date in the analysis period.

  - label: end date
    format: YYYY-MM-DD
    sample: 2024-12-31
    description: Final date in the analysis period.

The workflow pipeline refers to these inputs positionally:

pipeline:
  - reserve obs get GDP --start @1 --end @2 --format jsonl
  - reserve analyze summary

The first supplied value replaces @1, the second replaces @2, and the pattern can continue through @X.

Users and AI agents can inspect the required inputs before rendering the workflow:

reserve workflow contract gdp-summary

RESERVE displays the label, expected format, sample value, and description for each input:

personal/economic-growth/gdp-summary contract:
  @1 = start date
    format: YYYY-MM-DD
    sample: 2020-01-01
    description: First date in the analysis period.
  @2 = end date
    format: YYYY-MM-DD
    sample: 2024-12-31
    description: Final date in the analysis period.

Zero-input workflows are supported as a first-class use case. A workflow only needs a contract when its pipeline contains runtime slots.

Safe Rendering Instead of Execution

An important design decision in RESERVE 1.2.0 is that workflows do not execute pipeline content.

A workflow is rendered with:

reserve workflow render gdp-summary 2020-01-01 2024-12-31

RESERVE validates the workflow, binds the supplied values, and prints one copy-ready command:

reserve obs get GDP --start '2020-01-01' --end '2024-12-31' --format jsonl | reserve analyze summary

It does not invoke Bash, start another shell, or execute the rendered pipeline.

This boundary is intentional.

Shell execution introduces significant security and cross-platform questions, especially when workflow definitions may eventually come from public, educational, community, or private repositories. Version 1.2.0 keeps the operator or calling agent in control. The rendered command can be reviewed, copied, modified, audited, or executed through an environment chosen by the user.

A future release may introduce explicit rendering targets or controlled execution semantics. Those capabilities may only be added after their portability, trust, and security models are clearly defined.

Validation as a First-Class Feature

Because workflows are intended to become portable artifacts, validation must be more rigorous than simply checking whether a YAML file can be opened.

The new validator checks workflow structure, runtime contracts, pipeline placeholders, and collection-aware references:

reserve workflow validate personal/economic-growth/gdp-summary

Version 1.2.0 also adds several production safeguards:

  • Unknown YAML fields are rejected instead of being silently ignored.
  • Multiple YAML documents in one workflow file are rejected.
  • Runtime slots must match the declared contract.
  • Repository-style paths cannot traverse outside the configured workflow root.
  • Symlinks cannot be used to escape the workflow namespace.
  • A workflow’s reserve_version requirement is checked against the running CLI.
  • Rendering fails when required runtime values are missing or incompatible.

These rules help authors catch mistakes before publishing a collection and give users greater confidence when inspecting workflows obtained from another source.

A Repository-Aware Foundation

Workflows are organized using a three-part name:

repository/collection/workflow

For example:

personal/economic-growth/gdp-summary

Each part has a distinct purpose.

The repository identifies the source or trust boundary. The collection groups related analyses. The workflow identifies the individual analytical method.

Version 1.2.0 begins with local filesystem storage and uses personal as the default repository for user-authored workflows. The architecture also anticipates additional repository types:

  • official for workflows maintained and distributed by the RESERVE project
  • community for collections curated by organizations or subject-matter communities
  • education for universities, schools, instructors, and home-school networks
  • private for internal organizational analysis

Remote search, installation, synchronization, signing, and trust policies are not part of this foundational release. However, establishing repository-aware names now means those capabilities can be added later without redesigning the workflow identity model.

A university could eventually distribute a collection through GitHub. A research group could maintain an internal Git repository. A home-school network could publish a shared economics curriculum. RESERVE’s local commands can remain consistent regardless of how those collections are distributed.

Moving Beyond Snippets

Earlier versions included an exploratory feature called snippet.

Snippets helped test the idea that RESERVE pipelines could be saved and reused, but they did not provide the metadata, validation, contracts, collection structure, or repository model needed for a durable ecosystem.

Version 1.2.0 removes the experimental snippet feature and replaces it with workflows.

Because snippets were introduced as a silent exploratory feature and had not been promoted for general use, this was the right point to make a clean transition. Workflows now provide the foundation on which future sharing and distribution capabilities will be built.

Built with Go 1.27

RESERVE 1.2.0 also moves source builds to Go 1.27.

For a data-oriented CLI, the move to Go 1.27 is especially relevant. The release introduces the new encoding/json/v2 implementation, with the established encoding/json API now backed by the newer engine while preserving compatibility. The Go team reports significantly faster JSON unmarshalling, an important improvement for software that regularly processes API responses and JSONL observation streams.

Because RESERVE relies heavily on JSON responses from the FRED® API, we ran our own benchmarks against representative observation data. The results were striking.

Simply compiling RESERVE with the Go 1.27 toolchain produced approximately three times the JSON unmarshalling throughput and reduced unmarshalling time by about 68 percent.

Go 1.27 JSON improvements

Go 1.27 also introduces size-specialized allocation routines that can reduce the cost of small allocations. In our benchmarks, allocations fell by approximately 80 percent when processing large FRED observation payloads.

These are workload-specific benchmark results rather than a claim that every RESERVE command will run three times faster. They do, however, demonstrate a meaningful improvement in one of the CLI’s most important data-processing paths.

Go 1.27 also strengthens the development toolchain by checking for accidental use of standard-library features newer than the version declared by a module.

Together, these improvements provide a faster and stronger runtime foundation without changing how users interact with RESERVE. Prebuilt binaries remain self-contained, so users installing a RESERVE release do not need to install or upgrade Go separately. Go 1.27 or later is required only when building RESERVE from source, and no workflow or command compatibility changes are required.

More details are available in the official Go 1.27 release notes.

A Foundation for What Comes Next

RESERVE 1.2.0 is intentionally a foundational release.

It establishes:

  • A stable workflow YAML format
  • Static and dynamic workflow contracts
  • Repository and collection namespaces
  • Strict validation and version compatibility
  • Safe, non-executing pipeline rendering
  • Collection-level documentation
  • Local creation, discovery, inspection, editing, and removal
  • A clear path toward future workflow distribution

The next phase will be shaped by real workflow authors and real collections.

That means building analyses, documenting them, testing the contract model, determining which metadata proves useful, and learning how individuals, educators, researchers, and organizations want to distribute their work.

RESERVE began as a tool for retrieving economic data from the command line. It has steadily evolved into a composable environment for transforming, analyzing, and visualizing that data.

With version 1.2.0, those commands can now become durable analytical methods.

Create the workflow once. Validate it. Document it. Render it whenever the question returns.

RESERVE v1.1.9: Becoming More Agent-Friendly

One of the recurring goals in RESERVE development has been making the command-line interface easier to use without making it more complicated.

As the project has grown, the number of commands, pipelines, analysis tools, and configuration options has steadily expanded. Alongside that growth, RESERVE introduced structured onboarding designed not only for human users but also for AI assistants and automated development tools. Rather than treating documentation as something separate from the CLI, onboarding became part of the product itself.

That capability has continued to evolve over several releases.

Version 1.1.9 doesn’t introduce AI onboarding—it makes it easier to reach.

The release adds a global --ai-onboard switch that can be used from virtually any command path while preserving the existing reserve onboard workflow. Both entry points now share the same implementation and produce the same structured guidance, giving users and AI agents a more natural way to discover the CLI without introducing duplicate logic or inconsistent documentation.

AI Onboarding, Wherever You Enter

RESERVE has supported structured onboarding for some time through the reserve onboard command.

At the program level, onboarding can introduce an AI agent to the CLI, explain pipeline semantics, provide verified examples, document common gotchas, and even perform a token-conscious two-step handshake so large language models receive only the context they actually need. Command-specific onboarding has likewise been available for major command groups such as series, obs, transform, analyze, and config.

Version 1.1.9 extends that experience by adding a second, more natural entry point.

Instead of stepping outside the command you’re exploring, onboarding can now be requested directly:

reserve obs get CPIAUCSL --ai-onboard

The traditional approach continues to work exactly as before:

reserve onboard obs

or, for program-level onboarding:

reserve onboard --topic toc

Both approaches now arrive at the same destination.

The new global switch doesn’t replace the onboarding command—it simply makes onboarding available exactly where users and AI agents are already working.

One Onboarding System

Although there are now two ways to invoke onboarding, there is still only one onboarding implementation.

Whether guidance is requested through reserve onboard or via --ai-onboard, the CLI generates the same structured, machine-readable content from the same source. Examples, pipeline documentation, command references, and operational guidance remain synchronized automatically because they are produced by a shared code path rather than separate implementations.

For AI-assisted development, that consistency is important. Agents no longer need to learn a special onboarding command before asking for help with the command they’re already using. At the same time, maintainers only have one onboarding system to evolve, reducing the possibility that documentation and behavior drift apart over time.

RESERVE v1.1.8: Making Analysis Coherent

One of the recurring themes in RESERVE development has been that retrieving economic data is only the first step in the workflow.

Most users don’t stop after fetching a series from FRED®. They want to understand it. Is unemployment rising or falling? How closely does it move with interest rates? Has the behavior of a series changed over time? Are recent observations behaving differently than historical ones?

Previous releases gradually introduced analytical capabilities to help answer those questions. Summary statistics, trend analysis, transformations, and pipelines all expanded the platform beyond simple data retrieval. As those capabilities grew, however, it became increasingly clear that analysis needed to feel like a unified part of RESERVE rather than a collection of separate features.

Version 1.1.8 is largely about addressing that.

The release introduces new comparison and regime-analysis capabilities, adds rolling-window summaries and confidence reporting, and makes analysis output more consistent across the platform. Whether you’re summarizing a series, fitting a trend, comparing indicators, or looking for structural changes, the commands now work together more naturally and present results in a more consistent way.

Comparing Economic Indicators

Economic analysis is fundamentally comparative.

Inflation is interpreted relative to interest rates. Employment is evaluated alongside labor force participation. Market indicators are compared against policy measures. Very few economic series are meaningful in complete isolation.

Version 1.1.8 introduces analyze compare, a new command designed specifically for aligned-series analysis.

For example, comparing unemployment against the federal funds rate since 2010 can be performed with a single pipeline:

reserve obs get UNRATE FEDFUNDS --start 2010-01-01 --format jsonl | reserve analyze compare --against FEDFUNDS

+----------------+----------+
| METRIC         | VALUE    |
+----------------+----------+
| Series         | UNRATE   |
| Against        | FEDFUNDS |
| Aligned Obs    | 196      |
| Correlation    | -0.5884  |
| Beta           | -0.7063  |
| Delta Mean     | 4.2147   |
| Delta Last     | 0.6700   |
| Tracking Error | 3.5720   |
+----------------+----------+

Sources by series:
- UNRATE: Bureau of Labor Statistics via FRED
- FEDFUNDS: Board of Governors via FRED

Even this simple example reveals useful information immediately. The negative correlation reflects the tendency for unemployment and policy rates to move in opposite directions over long periods, while beta and tracking-error metrics provide additional context about the strength and consistency of that relationship.

Comparison results now retain the source information associated with each series. In the example above, the output identifies both the Bureau of Labor Statistics and the Federal Reserve as the underlying data providers. That information now flows consistently through analysis commands and output formats, making it easier to understand where analytical results originated.

Trend Analysis With Additional Context

Trend analysis has been part of RESERVE for several releases, but v1.1.8 expands the information available alongside trend estimates.

A trend can tell you whether a series is moving up or down, but that is only part of the story. Understanding how reliable that estimate may be is often just as important as the estimate itself.

The new --confidence option adds statistical measures that help put trend results into context, including standard errors, p-values, and confidence intervals.

For example:

 reserve obs get FEDFUNDS --start 2015-01-01 --format jsonl | reserve analyze trend --method linear --confidence
+----------------------+----------+
| METRIC               | VALUE    |
+----------------------+----------+
| Context              | -        |
| Series               | FEDFUNDS |
| Method               | linear   |
| Trend                | -        |
| Direction            | up       |
| Slope / Day          | 0.001174 |
| Slope / Year         | 0.4287   |
| Fit                  | -        |
| Intercept            | -0.3653  |
| R2                   | 0.5520   |
| Confidence           | -        |
| Slope StdErr         | 0.000091 |
| Slope P-Value        | 0.000000 |
| Slope CI95 Low       | 0.000995 |
| Slope CI95 High      | 0.001352 |
| Slope/Year CI95 Low  | 0.3635   |
| Slope/Year CI95 High | 0.4938   |
+----------------------+----------+

Source: Board of Governors via FRED

In this case, the analysis identifies a positive trend in the federal funds rate over the period while also reporting measures of uncertainty around that estimate. Rather than presenting a slope alone, RESERVE can now show the supporting statistics used to evaluate the strength and reliability of the result.

This additional context is especially useful when comparing trend estimates across multiple series or evaluating whether an apparent trend is likely to be meaningful rather than simply noise in the data.

Consistency Across Analysis

Many of the improvements in v1.1.8 are less visible than the new commands themselves.

Summary, trend, compare, and regime outputs now share a common table layout and presentation style. Numeric formatting has been standardized to improve readability while JSON and JSONL outputs remain optimized for automation and downstream processing.

The same formatting conventions now extend across observation retrieval, transformation workflows, and analysis commands. The goal is simple: users should spend less time adapting to different output formats and more time focusing on the data.

Version 1.1.8 also introduces rolling-window summaries through analyze summary --window N, allowing users to evaluate trailing periods instead of treating an entire series as a single historical block. Combined with the new comparison and trend enhancements, this creates a more complete analytical toolkit within the existing pipeline architecture.

Keeping Sources Attached to Results

One smaller but important improvement in v1.1.8 is that analysis output now handles source information more consistently.

In the comparison example above, RESERVE reports not only the analytical results but also the organizations responsible for the underlying data:

Sources by series:
- UNRATE: Bureau of Labor Statistics via FRED
- FEDFUNDS: Board of Governors via FRED

One of the goals of v1.1.8 was greater consistency across analytical workflows. Source information attached to data retrieval now remains attached as that data moves through analysis commands, helping ensure that results stay connected to the underlying series and organizations that produced them.

This is a relatively small change, but it becomes increasingly valuable as workflows grow more complex. The more transformations and analyses that occur between data retrieval and interpretation, the more important it becomes to keep the connection to the original data source visible.

Reliability Behind the Scenes

Version 1.1.8 also includes a number of infrastructure improvements that most users will never notice directly.

Live FRED traffic is now paced more conservatively, retry behavior better respects server guidance, and rate-limit handling has been refined to behave more predictably under constrained conditions. Testing infrastructure has likewise been updated to distinguish more effectively between live and offline environments.

These changes may not appear in screenshots, but they contribute to something equally important: confidence that analytical workflows behave consistently over time.

From Data Retrieval to Data Interpretation

The broader theme of v1.1.8 is analytical maturity.

RESERVE began as a way to make economic data easier to access. Over time it expanded into transformations, pipelines, caching, visualization, and reusable workflows. This release focuses on strengthening the next layer of that stack: helping users interpret the data they retrieve.

Comparison analysis, rolling summaries, confidence-aware trend reporting, provenance preservation, and experimental regime detection all support that objective.

The individual features matter, but the larger change is that analysis now feels increasingly like a coherent part of the platform rather than a collection of independent tools.

That’s an important step forward for RESERVE, and it lays the groundwork for future analytical capabilities still to come.

RESERVE v1.1.7: Toward Reusable Economic Data Workflows

The original design goals of RESERVE were straightforward: provide intuitive access to the FRED® API while extending that foundation with pipelines, transformations, and analysis capabilities in a single command-line environment.

As the platform has evolved, another design goal has emerged. RESERVE is no longer focused solely on executing commands; it is increasingly focused on helping users capture, repeat, and share economic data workflows.

Economic analysis is rarely a single command invocation. It is often a sequence of retrieval, transformation, filtering, summarization, and visualization steps that users repeat over time.

Version 1.1.7 introduces the first foundation for treating those workflows as reusable assets.

Introducing Snippet Libraries

The headline feature of this release is a new snippet command family:

reserve snippet set
reserve snippet list
reserve snippet get
reserve snippet run
reserve snippet delete

Snippets provide a mechanism for storing and reusing commonly executed command sequences.

Rather than maintaining shell history entries, personal notes, or external documentation, users can begin building a catalog of repeatable RESERVE workflows directly within the platform.

Importantly, snippets are backed by a filesystem-based library model rather than a temporary or session-oriented implementation.

This establishes a foundation that can scale beyond simple local convenience.

Today’s snippets may be personal workflow shortcuts.

Tomorrow they could become shared libraries, team standards, educational examples, or domain-specific analysis recipes.

Version 1.1.7 is intentionally a soft launch of that capability.

The goal is to establish the foundation before expanding the ecosystem around it.

Reproducibility Matters

Reusable workflows are only valuable if they produce consistent results.

A significant portion of this release focuses on strengthening the reliability of RESERVE’s batch-processing infrastructure through deterministic concurrency testing.

Batch observation and series retrieval now have dedicated testing coverage for:

  • Concurrency limits
  • Ordering guarantees
  • Warning behavior
  • Fallback paths

Previous test approaches relied on timing assumptions and sleep-based coordination.

The new test framework uses deterministic synchronization mechanisms that make behavior reproducible and easier to validate.

Most users will never see these changes directly.

But they contribute to something important:

Confidence that the same workflow behaves the same way every time it runs.

Preserving Attribution Through Pipelines

Another important improvement in v1.1.7 addresses metadata fidelity.

Recent releases have emphasized citations, provenance, and source attribution as first-class concerns within RESERVE.

This release extends that philosophy into transformation workflows.

Pipeline transformation commands now preserve citation metadata from upstream JSONL inputs, ensuring source attribution remains attached to data as it moves through transformations and resampling operations.

The principle is simple.

Transforming data should not erase information about where that data came from.

As workflows become more sophisticated, preserving provenance becomes increasingly important.

Small Improvements Matter

Not every enhancement in a release needs to be architectural.

Version 1.1.7 also improves ASCII chart rendering by standardizing numeric value labels to fixed two-decimal formatting.

Values such as:

59.00

now align consistently within chart output.

This is a small visual refinement, but one that improves readability when scanning larger datasets.

Polish accumulates over time.

And often the most frequently used features benefit the most from incremental improvements.

Building Beyond Individual Commands

The broader theme of v1.1.7 is not snippets themselves.

It is the idea that economic analysis consists of workflows rather than isolated commands.

  • Users retrieve data.
  • Transform it.
  • Compare it.
  • Visualize it.
  • Share the process.
  • Repeat it.

The new snippet library begins creating a place where those processes can be captured, reused, and eventually shared.

That makes this release more than a quality-of-life improvement.

It represents an early step toward a larger vision for RESERVE: not just a collection of economic data commands, but a platform for building repeatable economic data workflows.

Discovering FRED’s Hidden Treasures: From the Source

The Federal Reserve Economic Data (FRED®) platform is globally renowned as a massive repository of authoritative macroeconomic data. Series such as Gross Domestic Product (GDP), Consumer Price Index (CPIAUCSL), and the Unemployment Rate (UNRATE) appear in financial news headlines almost daily. Still, beyond these familiar indicators, FRED publishes more than 800,000 individual time series, many of which receive little public attention and are not tied to major press releases. Popularity, however, does not equate to insight potential.

For a curious mind interested in exploring this enormous data ecosystem, the obvious question becomes: where do you begin? One practical starting point is FRED sources.

Sources in FRED

As of the writing of this post the FRED system lists 499 sources all indexed with a source ID. Using RESERVE to list these is as easy as:

reserve source list

+-----+----------------------------------------------------------------+----------------------------------------------------+
| ID  | NAME                                                           | LINK                                               |
+-----+----------------------------------------------------------------+----------------------------------------------------+
| 1   | Board of Governors of the Federal Reserve System (US)          | https://www.federalreserve.gov                     |
| 3   | Federal Reserve Bank of Philadelphia                           | https://www.philadelphiafed.org/                   |
| 4   | Federal Reserve Bank of St. Louis                              | http://www.stlouisfed.org/                         |
. . . . .
| 499 | Barrero, Jose Maria                                            | https://www.jmbarrero.com                          |
+-----+----------------------------------------------------------------+----------------------------------------------------+

Using a source as a starting point, users can unpack what releases are associated with each source and which series are associated with a release. FRED’s data is organized in a

source -> release -> series

hierarchy. To illustrate the point, we are going to use source 499–economics professor and researcher Jose Maria Barrero. Before exploring the data, let’s have a real world understanding of Professor Barrero and the work with which he is associated.

Who is Jose Maria Barrero?

Jose Maria Barrero is an Associate Professor of Finance (with tenure) at Instituto Tecnológico Autónomo de México (ITAM) in Mexico City and an applied economist whose research focuses on finance, macroeconomics, and labor markets. He earned degrees in Economics and Mathematics from the University of Pennsylvania and completed both his MA and PhD in Economics at Stanford University. Professor Barrero is widely recognized for his research on remote and hybrid work, collaborating with Stanford economist Nicholas Bloom and Hoover Institution economist Steven J. Davis on influential work-from-home and labor market studies.

A Closer Look at the “Remote & Hybrid Work” Theme

Professor Barrero currently serves as one of nine members of The Survey of Working Arrangements and Attitudes (SWAA) research team. Per the SWAA website:

The Survey of Working Arrangements and Attitudes (SWAA) is a monthly survey of between 2,500 to 10,000 US residents aged between 20 and 64. We currently compile two versions of the data: (1) restricting to persons who earned  $10,000+ in the prior year, going back to May 2020; (2)  with no earnings restriction, going back to early 2022.

Within FRED, the release associated with this research is titled “Select Time Series Based on the U.S. Survey of Working Arrangements and Attitudes (SWAA).” The release currently contains 20 point-in-time series related to remote work, labor market expectations, and working arrangements.

Examples of series titles within the release include:

Series IDSeries Title
WFHCOVIDMATQUESTIONWork from Home Rate
WFHCOVIDFRACMATWOMENWork from Home Rate: Women
WFHCOVIDFRACMATMENWork from Home Rate: Men
WFHFRACMATGOVERNMENTWork from Home Rate: Government, Wage and Salary Employees

With this high-level overview, let’s use RESERVE to examine these details.

RESERVE Source Unpacking

The first order of business is using RESERVE to see releases associated with Professor Barrero. Per the output below, he is associated with exactly 1 release:

reserve source releases 499
+------+------------------------------------------------------------------------------------------+---------------+-------------------------------+
| ID   | NAME                                                                                     | PRESS RELEASE | LINK                          |
+------+------------------------------------------------------------------------------------------+---------------+-------------------------------+
| 1033 | Select time series based on the U.S. Survey of Working Arrangements and Attitudes (SWAA) | No            | https://wfhresearch.com/data/ |
+------+------------------------------------------------------------------------------------------+---------------+-------------------------------+

Note that this release contains a URL to the SWAA website. Furthermore, the entry has a value of “No” for Press Release meaning that FRED does not issue public press notifications for updates on this release.

To understand which series are related to this release, we will use the RESERVE release series command. The result is a collection of 20 series: 6 contain monthly observations and 14 contain annual observations.

reserve release series 1033
+---------------------------+----------------------------------------------------+------+----------------------+------------------------+
| ID                        | TITLE                                              | FREQ | UNITS                | LAST UPDATED           |
+---------------------------+----------------------------------------------------+------+----------------------+------------------------+
| FULLONSITECURR            | All Full-Time Wage and Salary Workers: Working ... | M    | %                    | 2026-05-05 11:10:38-05 |
| FULLREMOTECURR            | All Full-Time Wage and Salary Workers: Working ... | M    | %                    | 2026-05-05 11:10:37-05 |
| HYBRIDCURR                | All Full-Time Wage and Salary Workers: Working ... | M    | %                    | 2026-05-05 11:10:38-05 |
| WFHCOVIDFRACMATMEN        | Work from Home Rate: Men                           | M    | % of Full Paid Wo... | 2026-05-05 11:10:43-05 |
| WFHCOVIDFRACMATWOMEN      | Work from Home Rate: Women                         | M    | % of Full Paid Wo... | 2026-05-05 11:10:40-05 |
| WFHCOVIDMATQUESTION       | Work from Home Rate                                | M    | % of Full Paid Wo... | 2026-05-05 11:10:36-05 |
| WFHFRACMATARTSENTERTAIN   | Work from Home Rate: Arts & Entertainment, Wage... | A    | % of Full Paid Wo... | 2026-05-05 11:10:44-05 |
| WFHFRACMATEDUCATION       | Work from Home Rate: Education, Wage and Salary... | A    | % of Full Paid Wo... | 2026-05-05 11:10:43-05 |
| WFHFRACMATFINANCEINSURANC | Work from Home Rate: Finance & Insurance, Wage ... | A    | % of Full Paid Wo... | 2026-05-05 11:10:38-05 |
| WFHFRACMATGOVERNMENT      | Work from Home Rate: Government, Wage and Salar... | A    | % of Full Paid Wo... | 2026-05-05 11:10:42-05 |
| WFHFRACMATHEALTHCARE      | Work from Home Rate: Health Care & Social Assis... | A    | % of Full Paid Wo... | 2026-05-05 11:10:37-05 |
| WFHFRACMATHOSPITAILITYFOO | Work from Home Rate: Hospitality & Food Service... | A    | % of Full Paid Wo... | 2026-05-05 11:10:41-05 |
| WFHFRACMATINFORMATION     | Work from Home Rate: Information, Wage and Sala... | A    | % of Full Paid Wo... | 2026-05-05 11:10:44-05 |
| WFHFRACMATMANUFACTURING   | Work from Home Rate: Manufacturing, Wage and Sa... | A    | % of Full Paid Wo... | 2026-05-05 11:10:41-05 |
| WFHFRACMATPROFBUSSERVICES | Work from Home Rate: Professional & Business Se... | A    | % of Full Paid Wo... | 2026-05-05 11:10:39-05 |
| WFHFRACMATREALESTATE      | Work from Home Rate: Real Estate, Wage and Sala... | A    | % of Full Paid Wo... | 2026-05-05 11:10:41-05 |
| WFHFRACMATRETAIL          | Work from Home Rate: Retail Trade, Wage and Sal... | A    | % of Full Paid Wo... | 2026-05-05 11:10:42-05 |
| WFHFRACMATTRANSPWAREHOUSI | Work from Home Rate: Transportation & Warehousi... | A    | % of Full Paid Wo... | 2026-05-05 11:10:44-05 |
| WFHFRACMATUTILITIES       | Work from Home Rate: Utilities, Wage and Salary... | A    | % of Full Paid Wo... | 2026-05-05 11:10:42-05 |
| WFHFRACMATWHOLESALE       | Work from Home Rate: Wholesale Trade, Wage and ... | A    | % of Full Paid Wo... | 2026-05-05 11:10:43-05 |
+---------------------------+----------------------------------------------------+------+----------------------+------------------------+

Is Barrero the Only Source?

We found Release 1033 and related Series through exploring source 499–Jose Maria Barrero. In FRED, however, releases can have multiple sources associated with them and sources can be associated with multiple releases. In the case of series related to SWAA, there are actually 3 sources. In addition to Professor Barrero, Steven J. Davis (Source 104), and Nick Bloom (Source 105) are associated with the series associated with the SWAA Release.

reserve obs latest FULLONSITECURR
+----------------+------------+--------------+
| SERIES         | DATE       | LATEST VALUE |
+----------------+------------+--------------+
| FULLONSITECURR | 2026-04-01 | 62.93        |
+----------------+------------+--------------+

Sources: Barrero, Jose Maria; Davis, Steven J.; Bloom, Nick via FRED

Though many releases have exactly one source, this can never be assumed.

Why Explore A Niche Series?

Niche series provide context. Broad labor market indicators such as wage growth and employment levels are important, but they do not tell the entire story of how work itself is changing.

The Survey of Working Arrangements and Attitudes (SWAA) adds an additional layer of insight to traditional labor data by helping explain where and how that labor force is working. When combined with broader economic indicators, these datasets can help illuminate trends in commercial real estate demand, regional population shifts, workforce flexibility, and changing employer expectations.

Whether you are an economist, investor, policymaker, or hiring manager evaluating onsite versus remote work strategies, niche datasets like SWAA can provide valuable context that traditional headline indicators often miss.

Why Explore with RESERVE?

There are a number of ways in the modern world for exploring macroeconomic data consolidated on FRED. Options include, the FRED site itself, search engines like Google, answer engines like ChatGPT or Claude, and source websites like the Bureau of Labor Statistics or SWAA. However, RESERVE is a command-line interface designed to retrieve tabular data amongst other available formats. This allows the macroeconomics curious a very concise view of FRED’s 499 sources. With a source ID, it is fast and simple to explore Releases and Series associated with those releases. From there, data can be retrieved in comma-separated format for further work in Excel or in JSON/JSONL format for manipulation in Python. One can even go directly to the FRED website itself armed with new source, release, and series knowledge and use their GUI web tools to further explore. This explanation is limited to a single Release view of FRED data. Things get even more interesting when using RESERVE to retrieve data from series associated with multiple releases.

Combining Series

One of RESERVE’s powerful features is that it can download multiple series in a single command.

$ reserve obs get --start 2022-01-01 --freq annual PAYEMS CES0500000003 WFHCOVIDMATQUESTION
+---------------------+------------+--------+
| SERIES              | DATE       | VALUE  |
+---------------------+------------+--------+
| PAYEMS              | 2022-01-01 | 152549 |
| PAYEMS              | 2023-01-01 | 155895 |
| PAYEMS              | 2024-01-01 | 157694 |
| PAYEMS              | 2025-01-01 | 158439 |
| PAYEMS              | 2026-01-01 | .      |
| CES0500000003       | 2022-01-01 | 32.26  |
| CES0500000003       | 2023-01-01 | 33.70  |
| CES0500000003       | 2024-01-01 | 35.06  |
| CES0500000003       | 2025-01-01 | 36.44  |
| CES0500000003       | 2026-01-01 | .      |
| WFHCOVIDMATQUESTION | 2022-01-01 | 30.39  |
| WFHCOVIDMATQUESTION | 2023-01-01 | 28.81  |
| WFHCOVIDMATQUESTION | 2024-01-01 | 27.59  |
| WFHCOVIDMATQUESTION | 2025-01-01 | 27.12  |
| WFHCOVIDMATQUESTION | 2026-01-01 | .      |
+---------------------+------------+--------+

Sources by series:
- PAYEMS: Bureau of Labor Statistics via FRED
- CES0500000003: Bureau of Labor Statistics via FRED
- WFHCOVIDMATQUESTION: Barrero, Jose Maria; Davis, Steven J.; Bloom, Nick via FRED

This single RESERVE command combines two Bureau of Labor Statistics series with data from the Survey of Working Arrangements and Attitudes (SWAA) to compare employment growth, wage growth, and work-from-home trends after the pandemic.

The results are striking. From 2022 onward:

  • nonfarm employment continued to rise,
  • wages steadily increased,
  • yet remote work remained persistently elevated.

Early in the pandemic, many economists and employers expected work from home to disappear once the labor market normalized and offices reopened. Instead, the data suggests the opposite: even as employment recovered and wage growth remained strong, remote work stabilized at levels far above its pre-2020 baseline.

The important story is not that remote work declined from its pandemic peak — it is that it stopped declining. By 2024–2025, work from home appears to have settled into a new long-run equilibrium rather than reverting to pre-pandemic norms.

And that is where exploring The Source becomes especially valuable. Once we move beyond the most commonly cited FRED indicators, we begin to uncover datasets that capture how businesses and workers are adapting in real time. Widely followed economic indicators remain essential, but when combined with newer and more specialized datasets, FRED becomes more than a repository of statistics—it becomes a platform for discovering how the economy is actually changing.

RESERVE Pipelines Made Easy

A long string of piped commands can look intimidating at first glance. But they shouldn’t be. In this article, we’ll break down some of the most common RESERVE pipeline commands and show how they work together to build powerful workflows.

The Unix Philosophy

Command-line programs gained popularity in the 1970s with the adoption of an operating system called Unix. After nearly disappearing in the 1990s due to the rise of Microsoft Windows, they regained popularity in the 2000s and have since become mainstream once again. Throughout this evolution, these programs have been designed around a principle known as “The Unix Philosophy”:

Do one thing well and play well with others.

Modern command-line programs like RESERVE actually do many things well, but they are organized into commands and subcommands that keep each task focused and predictable.

RESERVE, for example, includes a series of wrapper commands whose primary goal is to provide direct, consistent access to the FRED API while allowing the user to choose different formats for displaying or storing data. The following command retrieves a range of GDP data and stores it in CSV format for easy import into a spreadsheet:

reserve obs get GDP --start 2024-01-01 --format csv > gdp_2024-26.csv

In addition to RESERVE’s formatting capabilities, this example also demonstrates the left-to-right flow that forms the basis of “play well with others.” In this case, RESERVE hands the data off to the operating system so it can be stored in a file. Just as easily, it could hand the data off to another application.

The Anatomy of a Pipeline

A pipeline takes the output of one command and passes it to another. This sequence flows from left to right.

RESERVE has three major categories of pipeline functionality. The first category consists of wrapper commands that directly access the FRED API and retrieve data. These include commands such as OBS GET and OBS LATEST.

$ reserve obs latest GDP
+--------+------------+--------------+
| SERIES | DATE       | LATEST VALUE |
+--------+------------+--------------+
| GDP    | 2026-01-01 | 31856.257    |
+--------+------------+--------------+

Source: Bureau of Economic Analysis via FRED

The second category includes true pipeline commands such as TRANSFORM. The idea is simple. A user can retrieve a long range of monthly data and then transform it into quarterly or yearly output.

For example, 20 years of UNRATE data can be resampled from monthly observations into quarterly averages like this:

$ reserve obs get UNRATE --start 2010-01-01 --format jsonl | reserve transform resample --freq quarterly --method mean
+--------+------------+----------+
| SERIES | DATE       | VALUE    |
+--------+------------+----------+
| UNRATE | 2010-01-01 | 9.833333 |
| UNRATE | 2010-04-01 | 9.633333 |
| UNRATE | 2010-07-01 | 9.466667 |
| UNRATE | 2010-10-01 |      9.5 |
. . . .

NOTE: In this example, the TRANSFORM command requires input in JSONL format.

The final category of RESERVE pipeline functionality is ASCII charting through commands such as PLOT and BAR. In the following example, the CHART command receives input from TRANSFORM and generates a visualization directly in the terminal. After all, RESERVE is a command-line interface.

$ reserve obs get UNRATE --start 2010-01-01 --format jsonl | reserve transform resample --freq annual --method mean | reserve chart bar
UNRATE  2010 – 2026
2010  9.61  ████████████████████████████████████████████████████████████████████
2011  8.93  ████████████████████████████████████████████████████████████
2012  8.08  ███████████████████████████████████████████████████
2013  7.36  ██████████████████████████████████████████
2014  6.16  █████████████████████████████
2015  5.28  ███████████████████
2016  4.88  ██████████████
2017  4.36  ████████
2018  3.89  ███
2019  3.68  █
2020   8.1  ███████████████████████████████████████████████████
2021  5.35  ████████████████████
2022  3.65  █
2023  3.62  █
2024  4.03  █████
2025  4.26  ███████
2026  4.33  ████████

Summary

Piped commands in a shell can look complicated at first, but they become much easier to understand when viewed as a logical sequence of steps.

In the examples throughout this post, the workflow was simple:

Get Data -> Transform Data -> Make a Visual

To become comfortable with pipelines, users should focus on understanding each stage independently. Every command should “do one thing well,” while the design of the pipeline handles the “play well with others” part automatically.

In practice, “others” can mean an entire ecosystem of commands and scripts.

Using the CHART example from above, a user can add a standard Unix utility like grep to filter noisy output without changing the original data request. Instead of modifying the OBS GET command or reducing the date range, the pipeline can simply filter the final output:

$ reserve obs get UNRATE --start 2010-01-01 --format jsonl | reserve transform resample --freq annual --method mean | reserve chart bar | grep 2015
2015  5.28  ███████████████████

This is the real strength of pipelines. Each command remains simple, focused, and reusable, but together they can produce powerful workflows with very little effort.