К основному содержанию
скилл CX Codex

econometric-orchestrator — скилл для Claude Code: анализ и установка

Скилл econometric-orchestrator для Claude Code координирует эконометрический анализ от выбора модели до диагностики результатов. Запускается для задач с VAR, BVAR, макроэкономическими временными рядами или репликацией научной статьи.

Apache-2.0 ★ 89 обновлён 2026-11-12

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add bis-med-it/marco-BIS --skill econometric-orchestrator -a claude-code
Открыть на GitHub

Что делает econometric-orchestrator

Скилл ведёт итеративный эконометрический анализ и координирует выбор модели, получение данных, оценивание, диагностику и журнал исследования. Он предлагает конкретные решения с обоснованием, а пользователь подтверждает их или просит альтернативы. Промежуточные результаты проходят проверку на экономическую осмысленность; при аномалиях скилл предлагает способы исправления.

Работа начинается в одном из трёх режимов: запуск модели из словаря, разбор новой статьи или разработка исследования по вопросу. В каждом случае ключевые решения остаются редактируемыми, а изменения и их причины записываются в журнал. Экономически существенные изменения требуют подтверждения и оформляются как отдельные проверки чувствительности рядом с базовым результатом.

Код создаётся на выбранном языке: Python, R, Julia или MATLAB. Скилл предпочитает готовые библиотеки, а собственный код пишет, только если для нужного метода нет надёжного пакета. Для исполнения значения записываются в config.yaml конкретного запуска и передаются как явные аргументы; корневой config.yaml задаёт предложения для будущих запусков, а не параметры уже созданных скриптов.

Какие задачи решает

  • выбрать модель для исследовательского вопроса
  • воспроизвести эконометрическую модель из статьи
  • проверить результаты VAR или BVAR на экономические аномалии
  • зафиксировать решения и изменения анализа в исследовательском журнале

Примеры запросов агенту

  • Проведи анализ макроэкономических временных рядов и предложи подходящую модель.
  • Оцени VAR для этой задачи и объясняй ключевые решения до продолжения.
  • Разбери эту статью и помоги воспроизвести её модель.

Как установить econometric-orchestrator

1Через Skills CLI (Vercel)

npx skills add bis-med-it/marco-BIS --skill econometric-orchestrator -a claude-code

2Вручную: положить файлы

~/.claude/skills/orchestrator/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/orchestrator/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы об econometric-orchestrator

Как установить econometric-orchestrator в Claude Code?

Выполни npx skills add bis-med-it/marco-BIS --skill econometric-orchestrator -a claude-code. Файл скилла размещается по пути ~/.claude/skills/orchestrator/SKILL.md.

Что делает econometric-orchestrator?

Он координирует эконометрический анализ: помогает выбрать модель, получить данные, оценить её и проверить результаты. Решения и итерации записываются в исследовательский журнал.

С какими задачами работает econometric-orchestrator?

Скилл поддерживает запуск модели из словаря, разбор статьи для последующего воспроизведения и разработку исследования по открытому вопросу.

Исходный текст

SKILL.md · Apache-2.0
---
name: econometric-orchestrator
description: >
  Orchestrates iterative econometric analysis using an agentic, human-in-the-loop workflow.
  Use this skill whenever the user wants to run a VAR, BVAR, or structural econometric model,
  asks for macroeconomic time-series analysis, has a research question and needs help
  choosing the right model, or submits a paper to replicate. Also triggers when the user says
  "run an econometric analysis", "estimate a VAR", "replicate Sims", "impulse responses",
  "what model should I use", "replicate this paper", or any request involving macro modelling
  with iterative refinement. Handles three entry modes: dictionary-driven (deterministic
  replication of a verified spec), paper submission (parse a new paper into a draft entry,
  then replicate), and research design (a spec designed from a research question using the model's
  parametric knowledge). This is the entry point that coordinates all sub-skills (model selection,
  data retrieval, estimation via scripts/lib/, diagnostics, research log).
---

# Econometric analysis orchestrator

This skill manages an iterative, human-in-the-loop agentic loop for econometric analysis.
It coordinates sub-skills and checks each step for economic sensibility
before proceeding.

## Design principles

1. **Everything is editable, always.** Any decision at any stage can be revised at
   any time. The framework never locks the user into a path. Revisions propagate
   forward automatically, and the research log tracks every version.
2. **Specific knowledge overrides parametric.** Every decision draws on specific
   sources before generic ones: in priority order, the user, the model
   dictionary, then the knowledge base (local context: economy profile, data
   sources, modelling conventions). Fall back to parametric knowledge only for
   gaps. The full cascade is defined once in the `specification` skill; always
   make the source of each decision transparent.
3. **Active suggestions, human confirmation.** At every choice point (model
   class, variables, lags, priors, identification, sample period, sensibility
   remedies, mode triage, data substitutions), propose a specific recommendation
   with rationale drawn from (in priority order) the dictionary, knowledge
   base, and parametric / economic-theory knowledge. The user confirms,
   overrides, or asks for alternatives. Never proceed silently; never ask a
   blank "what do you want?" question without offering a proposal first. The
   agent is a dialogue partner, not a form to fill out.
4. **Economic sensibility first.** Every intermediate output is evaluated against economic
   theory before being accepted. Flag anomalies (price puzzles, explosive roots, implausible
   magnitudes) and propose remedies.
5. **Iterative refinement.** If results fail sensibility checks, revise and
   re-estimate, but automatically only within Stage 5's class rules
   (implementation/data fixes and pre-specified statistical rules);
   economically substantive changes are gated proposals, run as labelled
   sensitivity exercises alongside the kept baseline.
6. **Tech-stack agnostic, package-first.** Generate code in whichever language
   the user prefers (Python, R, Julia, MATLAB). Always use the best available
   library or package for the task; do not reimplement standard algorithms
   from scratch. Only write custom code when no reliable package exists for
   the specific method needed.
7. **Fully logged.** Every decision, iteration, and rationale is recorded via the
   research-log sub-skill for reproducibility.
8. **One file of recommended defaults.** The starting proposals for tuneable
   settings (prior hyperparameters, draw counts, chart styles, data source
   preferences) come from `config.yaml` at the project root. The library does
   not load that file: write the values a run uses into the run's own
   `config.yaml` (and pass them as explicit arguments), because that file and
   those arguments are what govern execution. Editing the root file changes
   future proposals, not existing scripts; canonical replications keep their
   declared settings unless a deviation is approved and logged. Fields marked
   `[lib constant]` there are informational. Override order: config.yaml <
   knowledge base < runtime instruction (user always wins).
   (The one intentional exception: API key variable names / endpoints / rate limits live in
   `skills/data-retrieval/connections/connections.yaml`, because they are
   credentials and connection plumbing, not behaviour.)

## Three modes of entry

A session can begin in one of three modes. The orchestrator's first job (Stage 0b
below) is to identify which mode the request is in and route accordingly:

| Mode | When | What the orchestrator does |
|---|---|---|
| **A: Dictionary execution** | User names a paper / method with an entry in [`model-dictionary/entries/`](../model-dictionary/entries/); provides no novel content | Look up entry, run or generate `replicate.py`, skip spec design |
| **B: Paper submission** | User provides a paper (PDF / URL / citation) with no existing entry | Parse paper → draft entry (`verified.status: draft`) → user verifies → fall through to Mode A |
| **C: Research design** | User asks an open question with no named method | Run `model-selection`; if dictionary match → upgrade to A; else design from parametric knowledge |

If the request is ambiguous (e.g., it names a paper AND asks an open
question), ask before proceeding. Do not guess the mode silently. A wrong mode
choice wastes the user's time on the wrong work.

All three modes converge on the same execution pipeline (stages 2-7, with Stage 2 skipped in a deviation-free Mode A); only the
path *into* the specification differs. See [`modes.md`](modes.md) for full path
descriptions, transition examples, and a deeper reference.

### Source tiers

Mode A's lookup searches two source tiers (the scratch folder is listed for completeness but is not a source):

| Tier | Folder | Role | Gitignored? |
|---|---|---|---|
| **canonical** | [`scripts/replications/<id>/`](../../scripts/replications/) | Canonical replications, checked against the paper; public-good gallery | Scaffolding committed; `outputs/` ignored |
| **application** | [`scripts/applications/<id>/`](../../scripts/applications/) | User-specific past analyses (variants, adaptations, exploratory) | Scaffolding committed; `outputs/` ignored |
| **scratch** | `outputs/` (repo root) | Transient files from the current run | Always ignored; disposable |

Mode A ranks canonical above application but surfaces both. Successful Mode B
and Mode C runs get promoted to one of these tiers: applications by default;
canonical only after rigorous verification (`verified.status:
checked_against_paper` or higher in the dictionary entry).

`outputs/` at the repo root is **not** a source for the orchestrator. It is a
scratch space. If it disappears, no script is lost, because the script lives
in the relevant `scripts/<tier>/<id>/` folder. Generated model outputs are
regenerable, but session records (`session_research_log.json`,
`research_log.md`, `run_state.json`, any saved plan) are not: copy them out
before deleting any `outputs/` folder.

### Mode transitions

Modes are not one-way. A session can move between them mid-flow: **C → A**
(model-selection finds a clean dictionary match), **B → C** (paper extraction
fails or method is too novel), **A → C** (user deviates too far from the entry),
**C → B** (user produces a paper mid-design). Always announce the transition
explicitly and log it. See [`modes.md`](modes.md#mode-transitions-extended) for
worked examples.

## Revision protocol

Research is non-linear. The user will want to go back, change things, and see what
happens. The framework must make this effortless, not punishing.

### Core rule: any stage, any time

The user can revise any previous decision at any point in the workflow:

- "Actually, let's add the exchange rate to the model" → revises stage 2, re-runs 3-6.
- "Try Minnesota prior with tighter lambda" → revises stage 4 only, re-runs 4-6.
- "Can we see the same results as a policy brief instead?" → revises stage 6 only.
- "Let's switch to sign restrictions instead of Cholesky" → revises stages 2 and 4-6.
- "I want to start the sample from 2000 instead" → revises stage 3, re-runs 3-6.
- "Let me update the economy profile" → revises stage 0a, may affect all subsequent.

### How revisions work

1. **Identify what changed.** Parse the user's request to determine which stage(s)
   are affected.

2. **Determine the propagation scope.** Changes cascade forward but never backward:

   | Changed stage | Must re-run |
   |---------------|-------------|
   | 0a (knowledge base) | Potentially all; check which downstream decisions relied on the changed context |
   | 1 (model selection) | 2, 3, 4, 5, 6 |
   | 2 (specification) | 3 (if variables changed), 4, 5, 6 |
   | 3 (data) | 4, 5, 6 |
   | 4 (estimation) | 5, 6 |
   | 5 (sensibility) | 6 (if re-estimation triggered) |
   | 6 (presentation) | 6 only (re-render) |

3. **Preserve what hasn't changed.** If the user only changes the prior, don't
   re-fetch the data. If they only change the audience format, don't re-estimate.
   Re-use cached results from unchanged stages.

4. **Create a new version.** Every revision adds a version to the research
   log's `version_history` (schema in
   [`research-log/SKILL.md`](../research-log/SKILL.md)). Previous versions are
   never deleted, so the user can compare versions at any time.

5. **Present the diff.** When re-running after a revision, show the user what
   changed relative to the previous version:

   > "**Revision v1 → v2:** Added nominal effective exchange rate to the VAR.
   > Lag order unchanged (4). Cholesky ordering updated: exchange rate placed
   > after the policy rate.
   >
   > **Impact on results:** The price puzzle is resolved: prices now decline
   > after a monetary tightening. Output response is slightly smaller (-0.25%
   > vs -0.31% at peak). Exchange rate appreciates on impact, consistent with
   > UIP."

### What is editable

Everything: the knowledge base (stage 0a), the model class (stage 1), the
specification (variables, ordering, lags, identification, prior, sample), the
data (source, transforms, frequency, a user CSV), estimation settings (draws,
burn-in, convergence criteria, library or language), the sensibility checks
and their thresholds (for example, keeping a price puzzle the user justifies
on theoretical grounds), and every part of the presentation (audience, style,
language, narrative, components, format).

### Parallel specifications

The user may want to run multiple specifications simultaneously and compare:

- "Run this with 4 lags and 8 lags and show me both."
- "Estimate with Minnesota and Sims-Zha priors."
- "Give me BVAR and LP results side by side."

Keep each specification as a parallel branch in the research log (schema in
[`research-log/SKILL.md`](../research-log/SKILL.md)). `VARReport` can add a
baseline-versus-alternative comparison chart.

### Revision of skills themselves

The SKILL.md files and the root `config.yaml` are plain text. The user can
edit them, or ask the agent to, for example: "Change the default overall prior
tightness (lambda_1) in `config.yaml` to 0.2." Changes apply from the next
invocation. Adding methods to `scripts/lib/` is developer work (see
[DEVELOPMENT.md](../../DEVELOPMENT.md#how-to-add-a-new-estimation-method)).
The research log records the script path and a content hash for each
analysis.

### Graceful handling of mid-workflow changes

When the user interrupts the workflow to make a change:

1. **Acknowledge the change immediately.** Don't insist on completing the current
   stage first.
2. **Save current progress.** Whatever has been computed so far is preserved.
3. **Identify the minimum re-work.** Only re-run what's affected by the change.
4. **Confirm the plan.** Tell the user: "You've changed X. This means I need to
   re-run stages Y and Z. Stages A and B are unaffected. Shall I proceed?"
5. **Execute and present the diff.** Show what changed in the results.

## Workflow stages

### Run-completion contract

A run can go quiet before Stages 6-7 (report, disposition) when the user
pauses, pivots to another topic, or the context is compacted. Three
mechanisms keep every run visibly open until Stage 7 closes it:

1. **Durable run state.** From Stage 1 onward, maintain `run_state.json`
   next to the run's research log. Its schema and lifecycle are owned by the
   research-log skill
   ([`research-log/SKILL.md`](../research-log/SKILL.md#run-state-file-run_statejson)).
   Update it at every stage gate, in the same breath as the stage's log
   entry. It is the anchor that survives context compaction: on any resumed
   or compacted session, read it before acting.

2. **Harness task tracking.** At Stage 1 (once the mode is confirmed), if
   the harness offers task-tracking tools, create one task per remaining stage
   ("Stage 2: specification", … "Stage 7: disposition") and update each to
   in-progress / completed as the run crosses its gates. Pending stages then
   stay visible to agent and user independently of the conversation text.
   Without task tools, `run_state.json` alone carries the state.

3. **Definitions of done.** A stage is not complete until its outputs
   exist *and* its research-log entry is appended. Reporting is part of the
   work, not an epilogue:

   | Stage | Not done until |
   |---|---|
   | 1-3 | user confirmed the decision + log entry appended |
   | 4 | outputs written to the co-located `outputs/` + diagnostics run + log entry |
   | 5 | sensibility verdict presented (pass / flagged anomalies) + log entry |
   | 6 | `report.html` + narrative delivered + log entry |
   | 7 | disposition + tool review logged; `run_state.json` closed |

**Before concluding any reply that ends a piece of work** (results delivered,
question answered, error resolved): check the run state. If a run is `open`
at a stage below 7, either proceed to the next stage or state explicitly what
remains and propose when to do it. An explicit, logged deferral is fine;
silence is not.

### Stage 0a: Knowledge base initialisation (one-time)

Before any analysis, check whether a knowledge base exists for this context.

1. If `skills/knowledge-base/context/` is populated, load it and summarise the
   key parameters to the user for confirmation.
2. If empty (first use), ask the user to describe their economy and institutional
   context. Generate draft templates and present for review. This only happens once.
   **Fast path:** when the request is a standard-US / pre-collected-panel
   analysis (a canonical replication, or a Mode C question the dictionary
   already covers for the US), propose *skipping* the interview ("no local
   knowledge base needed for this run; the dictionary supplies the US
   context") and proceed once the user agrees. Do not force the onboarding
   interview on a context-free run. **Non-US one-offs:** the same fast path
   applies: propose proceeding with the dictionary anchor plus parametric
   local knowledge, *clearly labelled as parametric* in every source
   attribution, and offer to set up an economy profile only if the user
   expects recurring work on that economy.
3. If the user provides papers or references, process them into the knowledge base
   via the knowledge-base skill.

All subsequent stages consult the knowledge base before falling back to parametric
knowledge. The research log records which knowledge source informed each decision.

### Stage 0b: Intake & triage (per request)

Classify every request into Mode A, B, or C per the
[Three modes of entry](#three-modes-of-entry) section above. The triage is a
one-paragraph reasoning step:

1. **Scan the request** for the signals in the mode table.
2. **State the mode** to the user before proceeding: *"This looks like Mode A:
   you've named CEE (1999), which is in the dictionary."*
3. **If the signals are mixed or ambiguous, ask.** Do not silently pick a mode.

**Log the triage decision** in the research log, including the reasoning and any
dictionary entry that was matched. If the mode changes mid-session (see
[Mode transitions](#mode-transitions)), log that too.

### Stage 1: Mode-specific entry flow

The work in this stage depends on the mode determined in Stage 0b. Each path
produces the same output for downstream stages: a confirmed specification.

#### Stage 1A: Dictionary execution

The dictionary entry already names the model class, variables, identification,
and sample. The orchestrator's job here is:

1. Read the entry from
   [`skills/model-dictionary/entries/<id>.yaml`](../model-dictionary/entries/).
2. If [`scripts/replications/<id>/`](../../scripts/replications/) already exists,
   summarise its `config.yaml` and `README.md` to the user. Confirm any spec
   overrides the user wants (different sample, different data substitutions).
3. If no replication folder exists, sketch the equivalent: which
   [`scripts/lib/`](../../scripts/lib/) functions will be called (e.g.,
   `fit_var` → `cholesky_irf` → `VARReport`), what data is needed, what
   substitutions the FRED-MD/QD panels can supply.

**Wait for user confirmation** of the spec and any deviations before proceeding
to data collection. Then jump to Stage 2 only if the user requested deviations;
otherwise jump straight to Stage 3.

#### Stage 1B: Paper submission

The orchestrator must convert the paper into a verified dictionary entry before
estimation.

0. **Duplicate check first.** Identify the paper (open the file far enough
   to read the title page; never trust the filename) and search the
   dictionary for it: citation fields, `verified.pdf_location`, and ids.
   If a verified entry already exists, this is **Mode A, not B**: say so
   and route there instead of drafting a duplicate.
1. **Verify the staged file**, then extract the paper's spec. Integrity
   first: the file opens, the page count is plausible, the title page
   matches the user's citation. Report what you found before parsing.
   Use the `pdf` skill for PDFs, web fetch for URLs, or work directly
   from the user-provided text. **Image-only scans** (no text layer,
   common for pre-2000 JSTOR PDFs): render pages to PNG with a PDF renderer
   available in your environment (about 150 dpi for prose; re-render the tables, footnotes
   and data appendix that the specification depends on at ~300 dpi) and read the images;
   mind the scan-page vs journal-page offset when citing pages; flag any
   value you cannot read with confidence rather than guessing, and offer
   the user an OCR re-staging alternative.
2. Delegate to the `model-dictionary` skill to draft an entry following its
   [schema](../model-dictionary/SKILL.md#entry-schema). Save as a YAML under
   [`entries/<id>.yaml`](../model-dictionary/entries/) with an
   `AUTO-GENERATED: please verify` note. Verification status
   (`draft | checked_against_paper | signed_off`): an entry drafted
   **field-by-field from the staged PDF with a page reference on every
   field that defines the specification** is `checked_against_paper`, because drafting and
   checking coincide. An entry drafted from memory, an abstract, or
   secondary sources is `draft` until checked against the paper; see
   [DEVELOPMENT.md](../../DEVELOPMENT.md).
3. Present the draft to the user. Highlight: choice of identification, sample
   bounds, variable proxies, prior hyperparameters, any judgment calls the paper
   made implicitly. Make ambiguities visible; do not paper over them.
4. If the method is not implemented in [`scripts/lib/`](../../scripts/lib/),
   invoke `advisor-protocol` (if enabled) to derive the algorithm. Save the verified
   derivation as a reference document so it can become a new `scripts/lib/`
   function later.
5. After the user verifies the entry, **fall through to Stage 1A** with that
   entry as the spec source.

**Wait for user verification** of the draft entry before proceeding.

#### Stage 1C: Research design

Delegate to the `model-selection` sub-skill.

1. Understand the research question and analytical objective.
2. Assess data context (number of variables, sample length, frequency).
3. **Search the dictionary** for matching entries via the `model-dictionary`
   skill. If one or more strong matches exist, propose upgrading to Mode A
   with that entry, and announce the transition explicitly.
4. If no clean match exists, recommend 1-3 candidate model classes from
   parametric knowledge with rationale.
5. **Wait for user confirmation** before proceeding to specification design.

For a Sims (1980)-style request initiated as an open research question ("how
does MP affect output?"), this stage finds `sims_1980_var` and
`cee_1999_monetary_svar` in the dictionary and proposes upgrading to Mode A.

**Log this stage** via the research-log skill, including the mode and the
dictionary match (if any).

### Stage 2: Specification

**Mode applicability.** In Mode A, this stage is mostly a confirmation step:
the dictionary entry already determines everything. In Mode B, the dictionary
draft created in Stage 1B is the input; spec decisions become "verify or
override the draft." Mode C is where most spec design happens.

Delegate to the `specification` sub-skill, which owns the framework's
**canonical decision hierarchy** (defined once there; see
[`specification/SKILL.md`](../specification/SKILL.md#decision-hierarchy)):

> **user ▸ model dictionary ▸ knowledge base ▸ parametric knowledge ▸
> data-driven search**, with **economic logic** checked at every level.

Levels 2–4 *combine* rather than strictly cascade. The dictionary anchors,
the knowledge base adapts it to local context, and parametric reasoning fills
the gaps; the order is only the tie-breaker when two sources conflict on the same
field (in Mode A the dictionary anchor dominates for faithfulness; in Mode C
the knowledge base adapts it to the local economy). Data-driven search is
confined to hyperparameters / lag order, never variable selection or
identification.

The specification skill determines:
- **Variable selection:** theory-first, informed by knowledge base and literature.
  Never data-driven: variables are in the model because economics says they belong.
- **Lag order:** information criteria search (AIC, BIC, HQ) with economic logic
  override (e.g., residual autocorrelation, plausible transmission lags).
- **Prior hyperparameters:** literature defaults, optionally refined by grid search
  that screens only for stability and failed estimation. Economic checks (impact
  signs, price puzzle) are reported diagnostics: they trigger investigation and
  class-3 proposals (see Stage 5), not automatic rejection.
- **Identification:** purely theoretical choice, informed by the research question,
  knowledge base, and literature. Never selected by data fit.
- **Sample period:** determined by regime awareness (from knowledge base) and the
  trade-off between sample length and structural homogeneity.

Every decision includes its rationale and knowledge source (user, knowledge base,
literature, parametric, or data-driven) for full transparency.

In a dictionary run, read the specification from the entry (for example
`entries/sims_1980_var.yaml`) rather than recalling it, and summarise
variables, sample, deterministics, identification and lags.

Present the specification summary to the user and wait for confirmation before proceeding.

**Log this stage** via the research-log skill.

### Stage 3: Data collection

Delegate to the `data-retrieval` sub-skill:

1. Map each variable to a data source (default: FRED API).
2. **If the fetch will write new data to disk for the first time (a new dataset, a
   new source, or a manually pasted CSV), settle where it lives before fetching**,
   following data-retrieval's [runtime collection workflow](../data-retrieval/SKILL.md#runtime-collection-workflow)
   and [data-acquisition disposition](../data-retrieval/SKILL.md#data-acquisition-disposition)
   (scratch / cache / pre-collected / commit / discard). Skip when the storage
   policy is already agreed for this run or the dataset is already registered.
3. Retrieve the series programmatically.
4. Present a summary table: variable name, source series ID, frequency, sample coverage,
   units, seasonal adjustment status.
5. Propose transformations (log levels, first differences, seasonal adjustment) with
   economic rationale.
6. **Wait for user confirmation** of variable mapping and transformations.
7. Settle what happens to the fetcher recipe (ad-hoc / connector / lib fetcher) and
   any promotion of a cache to a pre-collected dataset. This is the data-layer
   analogue of Stage 7's code disposition; all these decisions get logged.

A canonical replication's variable mapping lives in its `config.yaml` (for
example `scripts/replications/sims_1980_var/config.yaml`). Some original
series have no exact FRED equivalent: identify the closest match, explain the
discrepancy, and let the user decide.

**Log this stage**, including both data-acquisition disposition choices (data tier
and fetcher tier) when steps 2 and 7 fire.

### Stage 4: Estimation

Estimation flows through [`scripts/lib/`](../../scripts/lib/README.md), the
Python library that wraps `statsmodels`, `scipy`, `numpy` and `plotly` and
adds the macroeconometric pieces those packages do not expose cleanly. Its
README is the authoritative module inventory.

There are no per-method skills: each method's conceptual documentation
lives in its `scripts/lib/` module docstring (and CONVENTIONS.md for the
pinned math conventions). The orchestrator generates a thin script that
loads config, calls library functions, and saves outputs.

1. **Generate a thin `replicate.py`-style script** (~150 lines) following the
   [conventions in `scripts/replications/`](../../scripts/replications/README.md).
   The script: reads its settings from its own folder's `config.yaml` (not the
   root file), loads data via
   `lib.load_dataset`, applies per-column transforms via `lib.transform`, calls
   `scripts/lib/` estimation functions, writes outputs to the script's
   **co-located** `outputs/` subfolder (`scripts/<tier>/<id>/outputs/`,
   excluded from version control; this is what every shipped replication does, and the repo-root `outputs/`
   is scratch only). Default working locations:
   - **Mode A**: use the existing script at
     [`scripts/replications/<id>/replicate.py`](../../scripts/replications/)
     (canonical) or [`scripts/applications/<id>/replicate.py`](../../scripts/applications/)
     (application). No new script needed unless the user requested deviations.
   - **Mode A with user deviations** (different sample, variables, economy):
     a variant is no longer canonical, so create a NEW folder at
     `scripts/applications/<descriptive_id>/` and leave the canonical
     replication untouched (same rule as Modes B/C below; see the source-tier
     table and `scripts/applications/README.md`).
   - **Modes B and C**: write the new script to
     `scripts/applications/<id>/replicate.py` as the working location. The
     **final tier** (stay in applications, promote to canonical, or be
     discarded) is decided in Stage 7 (Disposition & curation).
2. Estimate the model with the confirmed specification.
3. Report the outputs the method produces. For VAR-type fits these are
   coefficient summaries, posterior distributions (if Bayesian), lag length
   criteria (AIC, BIC, HQ) and stability (eigenvalues of the companion
   matrix); other methods report their own (e.g. filtered series, factor
   loadings).
4. Run the `diagnostics` sub-skill where it supports the fit; otherwise state
   which checks do not apply.

**Do not present impulse responses yet.** First confirm the model is well-specified.

**Log this stage**, including the exact lib functions called and their key
arguments (number of draws, lag order, identification scheme) so the run can
be reproduced from the log alone.

### Stage 5: Economic sensibility check

This is the critical gate. **Division of labour with Stage 4:** the
`diagnostics` sub-skill (Stage 4) owns *statistical* adequacy (residual
autocorrelation, ARCH, normality, companion-matrix stability). Stage 5
*consumes* those diagnostics (it does not recompute them) and adds the
*economic* judgement below. Evaluate:

1. **Stability.** Report the maximum root and classify the dynamics as stationary (below 1),
   unit-root (at 1 within sampling error) or explosive (above 1). Apply the
   declared model-class and replication criteria consistently, treat
   near-unit-root sampling uncertainty as a disclosed diagnostic, and do not
   certify stability from finite-horizon plots.
2. **Residual diagnostics.** No severe autocorrelation, heteroskedasticity broadly
   acceptable, normality a soft requirement.
3. **Sign and magnitude of key responses.** For a monetary policy shock (Sims example):
   - Does output decline? (expected)
   - Does the price level eventually decline? (if not, flag the "price puzzle")
   - Is the unemployment response consistent with Okun's law in magnitude?
   - **Convergence, conditioned on shock type.** Responses to *transitory*
     shocks should die out at reasonable horizons (24-40 quarters).
     Responses to *permanent* shocks (long-run-identified shocks such as
     Blanchard-Quah supply, or level responses in unit-root systems)
     must **flatten to a finite limit**, not vanish; demanding die-out
     there fails correct models by construction (the framework's own BQ
     replication is the canonical example).
4. **Forecast error variance decomposition.** Are the shares economically plausible?

If checks fail, diagnose the CAUSE first, then route by class:

1. **Implementation or data errors** (wrong transform, misaligned sample,
   mislabelled series, a coding slip): fix and...

© bis-med-it · Apache-2.0 · bis-med-it/marco-BIS

Похожие скиллы

Все скиллы по теме «Наука и исследования» →
statsmodels K-Dense-AI Скилл statsmodels для Claude Code подключает к агенту оценку и диагностику статистических моделей на Python: OLS, GLM, дискретные модели и временные ряды. Считает коэффициенты и проверяет допущения модели. CX Codex +1 2 400установок fred-economic-data franklee16 Скилл fred-economic-data для Claude Code запрашивает макроэкономические ряды через API FRED: инфляцию, ВВП, ставки и занятость. Полученные данные используют в финансовых отчётах и научных расчётах. CX Codex +1 ★ 240звёзд репо stata-regression Awesome Econ AI Community Скилл stata-regression помогает подготовить код регрессии в Stata, проверить данные и выгрузить таблицы для статьи или отчёта. Подходит для линейных и нелинейных моделей, фиксированных эффектов и кластерных ошибок. CX Codex +1 430установок r-econometrics Awesome Econ AI Community Скилл r-econometrics помогает строить эконометрические модели в R с проверкой допущений, робастными ошибками и таблицами для публикаций. Пригодится при оценке причинно-следственных связей. CX Codex +1 340установок stata-mcp SepineTam MCP-сервер, который даёт ИИ-агенту вызывать локальную Stata: регрессии, эконометрика, воспроизведение статей. Лицензия и данные остаются у вас. CX Codex +1 ★ 281звёзд репо simulation-study Claude Code Academic Workflow Скилл simulation-study создаёт и запускает воспроизводимые симуляции Монте-Карло на языке R. Помогает проверить смещение, охват доверительных интервалов и мощность оценок. CX Codex +1 ★ 1 729звёзд репо

Из того же набора12

Весь набор →
model-selection Скилл model-selection для Claude Code подбирает эконометрическую модель под исследовательский вопрос и доступные данные. Запускается, когда нужно выбрать подход или проверить уже выбранную модель. CX Codex +1 ★ 89звёзд репо research-log Скилл research-log для Claude Code ведёт журнал решений и этапов эконометрического анализа. Он подключается после завершения этапа другим скиллом MaRCo@BIS или по запросу на аудит, воспроизводимость либо сводку сессии. CX Codex +1 ★ 89звёзд репо knowledge-base Скилл knowledge-base для Claude Code согласует общие эконометрические знания агента с данными и правилами конкретной страны. Он подключается при настройке анализа или работе с местными источниками и исследованиями. CX Codex +1 ★ 89звёзд репо model-dictionary Скилл model-dictionary для Claude Code подбирает эконометрические спецификации по научной литературе. Агент ищет подход к исследовательскому вопросу или разбирает новую статью для словаря. CX Codex +1 ★ 89звёзд репо benchmarking Скилл benchmarking для Claude Code проверяет качество прогнозов и корректность результатов оценки. Запускается по запросу после расчёта модели или при подготовке результатов к публикации. CX Codex +1 ★ 89звёзд репо results-presentation Скилл results-presentation для Claude Code, который оформляет эконометрические результаты в графики, таблицы и текстовую интерпретацию. Запускается на этапе подготовки отчёта или по просьбе показать результаты и подготовить их к публикации. CX Codex +1 ★ 89звёзд репо specification Скилл specification для Claude Code помогает выбрать спецификацию эконометрической модели. Включается при выборе переменных, лагов, априорных параметров и способа идентификации. CX Codex +1 ★ 89звёзд репо data-retrieval Скилл data-retrieval для Claude Code и Codex управляет поиском и загрузкой данных для анализа. Он проверяет локальный реестр наборов перед запросом к API. CX Codex +1 ★ 89звёзд репо

Спонсоры проекта

Компании, которые помогают держать аналитику открытой