Model long-run behavioural change.

The model tracks 80 annual cohorts — households aged 20 to 99, entering at 20 and facing age-specific mortality. Each cohort chooses labour supply and saving over its remaining lifetime; firms rent that capital and labour; the government taxes, spends and issues debt. Two solves are on offer: the steady state ("where does the economy settle under this policy?") and the transition path — a multi-decade, year-by-year solve of how it gets there, which is what a budget profile needs.

It is the suite's long-run structural member. Where the OBR emulator answers "what does this do to the next twelve quarters of the official forecast?", this one answers "where does the economy end up, and why?" — with the behavioural mechanism visible rather than estimated.

The UK calibration is anchored to official data: depreciation from ONS capital-stocks data (6.5%/yr), potential-output growth from the OBR EFO (1.1%/yr), the discount factor matched to the ONS household saving ratio, the world interest rate to Bank of England gilt-yield data, and a Frisch labour-supply elasticity of 0.35–0.4 (Blundell, MaCurdy & Meghir). Demographics — population by age, mortality, immigration — come from UN data. Outputs map back to current-price £bn against live ONS series, falling back to cached values if ONS is unreachable.

Taxes are not stylized wedges. OG-UK runs PolicyEngine-UK on household microdata under baseline and reform, computes marginal rates by perturbation — add £1 of employment (or dividend) income per adult, rerun, read the change in net income — and fits three-parameter Gouveia–Strauss schedules to the effective-rate microdata for each year of a three-year budget window. The marginal-rate schedules are the analytical derivatives of the same fitted parameters, so ETR and MTRs are consistent by construction, and the model sees the reform's true shape across the income and age distribution.

start with pooled + single-sector and scale up only once the fast run answers your question. non-converging solve? raise max_iter (default 250), fall back to pooled, and check whether the reform is extreme — OLG models can diverge on very large shocks.

A Python package (3.11+); the recommended setup uses uv. The PolicyEngine enhanced-FRS microdata is downloaded on first run and is gated: you need a HUGGING_FACE_TOKEN with read access to policyengine/policyengine-uk-data.

git clone https://github.com/PSLmodels/OG-UK.git
cd OG-UK
uv sync
export HUGGING_FACE_TOKEN=hf_your_token_here
uv run python examples/run_oguk.py

the example script solves baseline and reform (a 1pp basic-rate rise) and prints £bn impacts — budget half an hour. prefer conda? conda env create -f environment.yml && conda activate oguk-dev && pip install -e . works too.

The whole scoring loop in one program — raising the basic rate of income tax from 20% to 21%:

from datetime import datetime
from policyengine.core import ParameterValue, Policy
from policyengine.tax_benefit_models.uk import uk_latest
from oguk import solve_steady_state, map_to_real_world

# 1. build a reform from PolicyEngine parameters
param = uk_latest.get_parameter("gov.hmrc.income_tax.rates.uk[0].rate")
reform = Policy(
    name="Basic rate 21%",
    parameter_values=[
        ParameterValue(parameter=param, value=0.21,
                       start_date=datetime(2026, 1, 1))
    ],
)

# 2. solve baseline and reform steady states — ~17 min each
baseline  = solve_steady_state(start_year=2026)          # no policy = baseline
reform_ss = solve_steady_state(start_year=2026, policy=reform)

# 3. map model units to real-world £bn
impact = map_to_real_world(baseline, reform_ss)

# 4. read the results
print(f"GDP change: {impact.gdp_change:+.1f}bn ({impact.gdp_pct:+.3f}%)")
print(f"Tax revenue change: {impact.tax_revenue_change:+.1f}bn")
print(f"Interest rate: {impact.r_baseline:.2%} → {impact.r_reform:.2%}")

Stack several ParameterValues in one Policy to score a package. Common parameter paths: gov.hmrc.income_tax.rates.uk[0..2].rate (basic 20%, higher 40%, additional 45%), gov.hmrc.income_tax.allowances.personal_allowance.amount (£12,570), and gov.hmrc.national_insurance.class_1.rates.employee.main / .higher.

Shocks that are not tax-and-benefit statute go through param_overrides, a dict of OG-Core parameters applied on top of everything else. Corporation tax lives here, not in PolicyEngine — it is a structural parameter of the macro model:

# corporation tax cut to 25%
ss = solve_steady_state(param_overrides={"cit_rate": [[0.25]]})

# productivity: +0.4% TFP level shock
ss = solve_steady_state(param_overrides={"Z": [[1.004]]})

# statutory reform, structural shock, and finer tax functions in one run
ss = solve_steady_state(policy=reform,
                        param_overrides={"cit_rate": [[0.25]]},
                        age_specific="brackets", multi_sector=True)

The transition path answers "what happens each year on the way there" — decade by decade, baseline and reform in one call, on Dask workers:

from dask.distributed import Client
from oguk import run_transition_path, map_transition_to_real_world

client = Client(n_workers=4, threads_per_worker=1)
base_tp, reform_tp = run_transition_path(start_year=2026, policy=reform,
                                         client=client)
client.close()

impact = map_transition_to_real_world(base_tp, reform_tp)
# impact.years            → ["2026-27", "2027-28", ...]
# impact.gdp_change[t]    → £bn change from baseline in year t
# same arrays for consumption, investment, revenue, debt

transition paths are available through the oguk API but are not wired into the PolicyEngine Macro CLI yet — the CLI is steady-state only. Two commands are wired: pe-macro og-baseline and pe-macro og-score --reform '{"gov.hmrc.income_tax.rates.uk[0].rate": 0.21}', both on the fast configuration (pooled tax functions, single sector, steady state).

map_to_real_world() returns a MacroImpact carrying, for each aggregate, the reform level, the change from baseline, and the percent change — all current-price £bn — plus baseline and reform interest rates:

• .gdp / .gdp_change / .gdp_pct
• .consumption, .investment, .government — same triple each
• .tax_revenue, .debt — same triple each
• .r_baseline, .r_reform — steady-state interest rates

The £bn mapping is GDP-anchored: one scale factor (real-world GDP ÷ model GDP) converts model-unit changes, with levels anchored to live ONS series (GDP, consumption, investment, government, debt ratio) and HMRC total receipts.