Test US monetary and fiscal shocks.

This reimplements the large-scale macroeconometric model the Federal Reserve Board has used for policy analysis and forecasting since 1996. The Board publishes the whole thing — the equation system as model.xml, the LONGBASE historical and projection database, the model documentation, and a reference Python solver called pyfrbus — in the public domain. What it does not publish is a modern, readable, dependency-light implementation you can drop into a research stack.

This is that: a from-scratch build on numpy, scipy and sympy under Python 3.10+, parsing the Board's own model file rather than re-specifying it. It carries 284 endogenous variables and their equations, classified into behavioural and identity blocks exactly as the Board's file declares them, and solves them as one simultaneous system per quarter.

In the suite it plays the role for the United States that the OBR emulator plays for the United Kingdom: reproducing the estimated equation system an official institution actually relies on, rather than deriving behaviour from first principles the way the overlapping-generations model does. The two diverge on one point that shapes everything below: the OBR emulator has a bridge from statute, and this one does not.

The reference implementation decomposes each period into recursive and simultaneous blocks; this one solves the whole period at once. Both approaches solve the same F(x) = 0, which is why the two agree to solver tolerance rather than to some negotiated threshold — see how far to trust it below.

The quickest route is the hosted MCP server, where three tools reach this model: frbus_list_variables (the shockable levers, with their units), frbus_shock (solve and return impulse responses), and frbus_summary (vintage and validation provenance). A solve takes about 3 seconds cold and well under a second warm — the fastest member of the suite. The same three are on the CLI:

pe-macro frbus-variables
pe-macro frbus-shock --var rffintay_aerr --shock 1.0
pe-macro frbus-summary

Two traps. Shock sizes are per-lever and not interchangeable: rffintay_aerr is in percentage points (1.0 = a 100bp tightening), but the spending levers such as egfe_aerr are in log points of quarterly growth, not billions of dollars — a dollar-sized number there diverges the solver. And each policy rule reads its own add-error, so rffintay_aerr works only under inertial_taylor; asking for it under taylor is rejected with a pointer to rfftay_aerr rather than silently returning all-zero responses.

frbus_shock takes a policy_rule, and the choice is usually the economic point of the exercise: inertial_taylor (the default, the LONGBASE rule and the one the validation numbers use), taylor, or fixed_funds_rate, which holds the funds rate on its baseline path so there is no endogenous monetary offset. A four-quarter federal-purchases shock of 0.01 log points peaks higher on real GDP with the funds rate fixed than under the inertial rule — and the price-level response is larger still without the monetary offset.

For the full 284-variable model, the Board's own demo scripts, or anything the three tools do not expose, install the package. It is separate from the rest of the suite, with its own Python API. The Board's raw materials are vendored unmodified in the repository, so there is no data-download step, but you do clone rather than pip-install from an index.

git clone https://github.com/PolicyEngine/us-frb-model
cd us-frb-model
uv venv && uv pip install -e ".[dev]"

import pandas as pd
from frbus import Frbus, load_data

data = load_data("vendor/data_only_package/LONGBASE.TXT")
model = Frbus("vendor/pyfrbus_package/models/model.xml")

start, end = pd.Period("2026Q1"), pd.Period("2030Q4")

# the fiscal-policy configuration the Board's own demos use
data.loc[start:end, "dfpdbt"] = 0
data.loc[start:end, "dfpsrp"] = 1

# add-factor the model so the baseline reproduces LONGBASE exactly
with_adds = model.init_trac(start, end, data)

# 100bp monetary policy shock in the first quarter
with_adds.loc[start, "rffintay_aerr"] += 1
sim = model.solve(start, end, with_adds)

print((sim.loc[start:end, "xgdp"] / with_adds.loc[start:end, "xgdp"] - 1) * 100)

a runnable copy of exactly this is examples/monetary_policy_shock.py. The API surface mirrors the essentials of pyfrbus's Frbus class: Frbus(path), .init_trac(), .solve(), .exogenize() — so the Board's own demo scripts port across with minimal change.

The model's designed job is the dynamic response of the US economy to a policy impulse. A 100bp funds-rate tightening in 2026Q1 moves the policy rate +1.000pp on impact, pushes real GDP to a trough of −0.55% in 2027Q4, raises unemployment by a peak +0.26pp, and takes core inflation down 0.034pp at its trough — signs, magnitudes and timing consistent with the simulation properties in the Board's own frb-us documentation.

Fiscal impulses land in the published cross-model ranges. A government-purchases shock worth 1% of GDP gives a year-one multiplier of 0.72 under the inertial Taylor rule, inside the 0.7–1.0 no-accommodation range in Coenen et al. (2012); holding the funds rate fixed, the year-two multiplier is 0.99. A personal tax cut worth 1% of GDP ex ante gives 0.22 rising to 0.32 over years one and two, inside both the 0.2–0.4 cross-model range and CBO's central estimate of about 0.3.