Agent skill

Quant Experiment Runtime

by CamusGIT in CamusGIT/EvoQuant

Quant research experiment executor: discover an offline source database under the workdir's code-repo, build a panel, run a Research Artifact's entry point to compute research-object values, and…

Apache-2.0Auto-check passedDevelopment

Install Quant Experiment Runtime

skills CLI
$ npx skills add CamusGIT/EvoQuant --skill quant-experiment-runtime -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install CamusGIT/EvoQuant quant-experiment-runtime --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/CamusGIT/EvoQuant.git skills-src && mkdir -p .claude/skills && cp -r skills-src/EvoQuant/skills/quant-experiment-runtime .claude/skills/quant-experiment-runtime && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
quant-experiment-runtime
GitHub stars
151
Token cost
~2.5k tokens
SKILL.md length
795 words
Files
16 (incl. scripts, references, assets)
Skills in repo
6
Repo updated
First seen
Licence
Apache-2.0

At a glance

Quant research experiment executor: discover an offline source database under the workdir's code-repo, build a panel, run a Research Artifact's entry point to compute research-object values, and…

  • Works in 3 steps: Run discover_data.py --code-repo… → Inspect the catalog, pick a dataset, and… → data-root / --panel are required, with…
  • : a research proposal is ready and you need to actually run the proposed factor/method on real data and get quantitative metrics
  • SKILL.md covers Mental model: Runtime =…, When to use, When NOT to use and The convention that constrains…, plus 8 more sections
  • Runs Python scripts from its folder; calls python and docker

What it does

Quant Experiment Runtime is an agent skill from CamusGIT/EvoQuant. Quant research experiment executor: discover an offline source database under the workdir's code-repo, build a panel, run a Research Artifact's entry point to compute research-object values, and evaluate IC/ICIR/RANKIC/coverage metrics. Runtime = Experiment Executor; it runs a Research Artifact via a Python-native Entry Point and is agnostic to research-object type and expression form. Self-contained: panel building and IC metrics are implemented inside this skill. The dataset is identified at runtime by…

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 19 other files, including scripts, reference files and assets (for example `assets/candidate-template.json`, `assets/discover-output-example.json` and `assets/experiment-result-schema.json`).

It sits in Development. It works with Python. The repository describes itself as: EvoQuant is a self-evolving AI research agent specialized in quantitative investment research. It runs the full research loop autonomously. The licence is Apache-2.0.

When your agent uses it

  • : a research proposal is ready and you need to actually run the proposed factor/method on real data and get quantitative metrics
  • : designing which experiments to run (use experiment-pipeline / paper-planning)
  • Debugging a single failed experiment (use experiment-craft)
  • Searching papers (use local-paper-navigator)

Example prompts

  • “s code-repo, build a panel, run a Research Artifact”
  • “/quant-experiment-runtime”

Requirements

  • Python 3
  • Docker
  • Pre-approved tools (allowed-tools): write_file, edit_file, read_file, think_tool, execute

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. Run discover_data.py --code-repo code-repo → a JSON catalog of every
  2. Inspect the catalog, pick a dataset, and pass its root to
  3. data-root / --panel are required, with no default — the dataset name

What it can do on your machine

Read from SKILL.md and the folder at commit ac1c4b8. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • write_file
    • edit_file
    • read_file
    • think_tool
    • execute

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 6 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python
    • docker

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use docker, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Quant Experiment Runtime loads about 2.5k tokens when it runs, and up to ~5.9k if it reads all its reference files. Until then it costs about 229 tokens; SKILL.md has 795 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~229
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from CamusGIT/EvoQuant at commit ac1c4b8, republished under its Apache-2.0 licence (© CamusGIT). 795 words, ~2,510 tokens.

Download SKILL.mdSave it as .claude/skills/quant-experiment-runtime/SKILL.md (or your agent's skills folder). This skill also uses 15 other files; get the full folder from GitHub.
name
quant-experiment-runtime
description
Quant research experiment executor: discover an offline source database under the workdir's code-repo, build a panel, run a Research Artifact's entry point to compute research-object values, and evaluate IC/ICIR/RANKIC/coverage metrics. Runtime = Experiment Executor; it runs a Research Artifact via a Python-native Entry Point and is agnostic to research-object type and expression form. Self-contained: panel building and IC metrics are implemented inside this skill. The dataset is identified at runtime by discover_data.py (never hard-coded). Use when: a research proposal is ready and you need to actually run the proposed factor/method on real data and get quantitative metrics. Do NOT use for: designing which experiments to run (use experiment-pipeline / paper-planning), debugging a single failed experiment (use experiment-craft), or searching papers (use local-paper-navigator).
allowed-tools
write_file, edit_file, read_file, think_tool, execute
metadata.author
quant-research-team
metadata.version
1.0.0
metadata.tags
core, experimentation, quant, runtime, executor, data, metrics

Quant Research Experiment Runtime

An Experiment Executor for quant auto-research: take a Research Artifact (LLM-generated, exposing a callable entry point), run it against a real offline source database to compute research-object values, and evaluate quantitative metrics. It does not design experiments (that is experiment-pipeline) — it executes one.

Mental model: Runtime = Experiment Executor

Workflow (experiment-pipeline)   ── owns when/whether to run
        │
        ▼
Experiment Runtime               ── owns how to run one experiment
        │
        ▼
Research Artifact                ── a runnable research product (py file / package / future workspace|docker|notebook)
        │
        ▼
Entry Point                      ── Python-native callable, e.g. "path/to/code.py::run" or "pkg.mod:run"
        │
        ▼
Results                          ── Runtime does NOT interpret; Metric does
        │
        ▼
Metric (registry, extensible)    ── evaluates; does NOT realign
        │
        ▼
ExperimentResult (+ artifacts/) ── Reflection / downstream Workflow depend only on this

The Runtime only knows "I run a Research Artifact via its Entry Point." It is agnostic to: research-object type (factor / generation method / portfolio), expression form (DSL / python / generator), and the internal structure of results. Those belong to the Research Artifact / Workflow / Metric.

This skill is self-contained: panel building (scripts/_panel.py) and IC metrics (scripts/_metrics.py) are implemented inside the skill and need only pandas / pyarrow / numpy. There is no dependency on any external factor-research project.

When to use

  • You need to actually run the proposed object on real data.
  • Experiment needs concrete IC-style metrics.
  • You need to evaluate a batch of candidates.

When NOT to use

  • Designing which experiments to run / stage budgets → experiment-pipeline.
  • Debugging a single failed experiment → experiment-craft.
  • Searching/reading papers → local-paper-navigator.

The convention that constrains LLM-generated code

LLM-generated research code is constrained by this convention, not by Python types:

A Research Artifact exposes one Entry Point — a callable with signature entry(context, config) -> results. The function name is not fixed (run/experiment/evaluate/main all fine); compute_ref names it. results default contract for the IC metric is dict[split, pd.Series] where each Series is factor exposure already aligned to that split's panel index — alignment is the research code's job, the Metric only evaluates.

See references/research-code-convention.md for the full contract and assets/research-artifact-example/ for a runnable copy-pasteable example.

Database identification contract

The dataset is not hard-coded. The agent identifies it at runtime:

  1. Run discover_data.py --code-repo code-repo → a JSON catalog of every data package under the code-repo (each entry has name, root, artifacts_root, file list, coverage).
  2. Inspect the catalog, pick a dataset, and pass its root to build_panel.py --data-root <root>.
  3. --data-root / --panel are required, with no default — the dataset name must come from the discover step, never hard-coded in a Candidate or script.

Paths follow the convention: script paths use the /skills/ virtual mount (/skills/<skill>/scripts/..., resolved by the EvoQuant sandbox to the installed skill directory — same convention used by paper-graph); data/output paths point into the EvoQuant workdir and may be given relative to the workdir (with the workdir as cwd) or as absolute paths. In docs, a leading / denotes the workdir root (e.g. /code-repo/, /experiments/); in shell commands these are plain relative paths (code-repo, experiments/...).

How to run (minimal demo)

Run with the EvoQuant workdir as cwd (the code-repo lives at code-repo under it). Script paths use the /skills/ virtual mount, matching the convention (python /skills/<skill>/scripts/<x>.py); data/output paths are relative to the workdir (cwd). Experiment outputs go under the current cycle's project directory experiments/<project>/ (see experiment-pipeline's "Project directory" convention — one per research cycle).

bash
# 1. discover usable datasets under the code-repo (autonomous, no hard-coded names)
python /skills/quant-experiment-runtime/scripts/discover_data.py --code-repo code-repo --out catalog.json

# 2. from catalog.json pick datasets[i].root, then build the panel offline
python /skills/quant-experiment-runtime/scripts/build_panel.py \
  --data-root <selected-dataset-root> \
  --out experiments/<project>/panel_1d.parquet

# 3. run an experiment (single or batch Candidate JSON -> ExperimentResult JSON)
python /skills/quant-experiment-runtime/scripts/run_experiment.py \
  --panel experiments/<project>/panel_1d.parquet \
  --candidate /skills/quant-experiment-runtime/assets/candidate-template.json \
  --label-col label_1d_close_to_close --splits train val \
  --artifacts-dir experiments/<project>/artifacts --out experiments/<project>/result.json

<selected-dataset-root> is whatever discover_data.py reported for the chosen dataset (e.g. code-repo/<dataset-folder>); it is never typed by hand from memory.

A Candidate JSON points its compute_ref at the Research Artifact's entry point (see assets/candidate-template.json). The example artifact at assets/research-artifact-example/factor.py computes a 20-day reversal factor and is the reference LLMs should imitate.

Show full SKILL.md (275 more words)Show less

What the Executor owns (vs Workflow / Research Artifact)

LayerOwns
Workflow (experiment-pipeline)when/whether to run; stage budgets; reflection → evo-memory
Executor (this skill)data discovery/load, train/val/test split, calling the Entry Point, Metric evaluation, artifacts dir, ExperimentResult
Research Artifact (LLM-generated)the object's logic, expression form, alignment, byproducts
Metrichow to evaluate results (only evaluate; never realign)

Demo scope

  • Demo-verified: Alpha Factor Research (single + batch). Optional: Alpha Generation Methodology (run_batch).
  • Scaffolded, not demoed: Portfolio Strategy Research. No portfolio Metric is registered yet — only ic_panel. SKILL.md does NOT claim all three types are demoable. Adding a portfolio Metric later requires no Runtime change (register it; see references/metrics-extension.md).

Train / val / test

Split is ratio-based, not hard-coded years (data coverage changes over time). Defaults: train 56% / val 22% / test 22% of coverage; test is opt-in. The agent may override dates/ratios/label_col via --split-config. See references/split-policy.md.

Extensibility

  • New Metric: metrics_registry.register(name, fn) — see references/metrics-extension.md.
  • New Research Artifact form (package/workspace/docker): the Entry Point abstraction already accommodates this; only load_entry_point may need a new loader. Candidate/ExperimentResult/Entry-Point signature do not change.
  • New research-object type: a new Research Artifact + (if needed) a new Metric. No Runtime branching.

Reference Navigation

TopicFile
Entry Point / RuntimeContext / Candidate / ExperimentResult contractreferences/runtime-interface.md
What research code must implement + alignment duty + examplesreferences/research-code-convention.md
Train/val/test rules, fixed vs overridable, 4-stage alignmentreferences/split-policy.md
Registering new metrics / experiment typesreferences/metrics-extension.md
Runnable factor Research Artifact exampleassets/research-artifact-example/factor.py
Candidate input templateassets/candidate-template.json
ExperimentResult schemaassets/experiment-result-schema.json
Example split configassets/split-config.example.json

Skill Integration

StageAction
From experiment-pipeline Stage 1/3build panel → run Candidate → get IC metrics → record in stage log
From experiment-pipeline (batch)run_batch a generation round, evaluate distribution
To evo-memory / reflectionhand off ExperimentResult + artifacts/
Seeexperiment-pipeline/references/quant-experiment-integration.md for calling-time contract

© CamusGIT, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 15 other files (scripts, references, assets) in EvoQuant/skills/quant-experiment-runtime of CamusGIT/EvoQuant.

  • SKILL.md
  • assets/candidate-template.json
  • assets/discover-output-example.json
  • assets/experiment-result-schema.json
  • assets/research-artifact-example/factor.py
  • assets/split-config.example.json
  • references/metrics-extension.md
  • references/research-code-convention.md
  • references/runtime-interface.md
  • references/split-policy.md
  • scripts/_metrics.py
  • scripts/_panel.py
  • scripts/build_panel.py
  • scripts/discover_data.py
  • scripts/experiment_runtime.py
  • scripts/run_experiment.py

Open the folder on GitHubat commit ac1c4b8

Compare with similar skills

Quant Experiment Runtime next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Quant Experiment Runtime compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Quant Experiment Runtime this skillCamusGIT/EvoQuant151—~2.5kAutomated safety check: PassApache-2.0
Code Review ChecklistshareAI-lab/learn-claude-code78k5 repos~1.1kAutomated safety check: PassMIT
Merge Dependabot PRsonyx-dot-app/onyx32k1 repos~2.2kAutomated safety check: PassMIT
Kedro Babysitkedro-org/kedro11k—~4kAutomated safety check: PassCustom licence
LangBot Plugin Developmentlangbot-app/LangBot18k—~3.9kAutomated safety check: PassApache-2.0
Senior Architect Toolkitmaslennikov-ig/claude-code-orchestrator-kit2597 repos~1.2kAutomated safety check: NotesCustom licence

Similar skills

  • Code Review Checklist

    shareAI-lab/learn-claude-code

    Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.

    78k GitHub starsUsed in 5 repos~1.1k tokens
    DevelopmentAuto-check passed
  • Merge Dependabot PRs

    onyx-dot-app/onyx

    Triages and lands a batch of open Dependabot PRs in the Onyx repo, where main is gated exclusively by GitHub's merge queue: approves and enqueues green PRs, closes superseded duplicates, fixes…

    32k GitHub starsUsed in 1 repo~2.2k tokens
    DevelopmentAuto-check passed
  • Kedro Babysit

    kedro-org/kedro

    Run Kedro's local lint / format / type-check / tests on changed files (uses the project's pre-commit hooks, ruff, mypy, pytest, lint-imports, detect-secrets, Make targets — in the right venv), or…

    11k GitHub stars~4k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • LangBot Plugin Development

    langbot-app/LangBot

    Guides building, debugging and testing LangBot plugins: components, SDK calls, README and locale rules, SDK pitfalls and WebSocket-based testing.

    18k GitHub stars~3.9k tokensUpdated today
    DevelopmentAuto-check passed
  • Senior Architect Toolkit

    maslennikov-ig/claude-code-orchestrator-kit

    Comprehensive software architecture skill for designing scalable, maintainable systems using ReactJS, NextJS, NodeJS, Express, React Native, Swift, Kotlin…

    259 GitHub starsUsed in 7 repos~1.2k tokens
    DevelopmentAuto-check: notes
  • Flowsint Enricher Builder

    reconurge/flowsint

    Guides building Flowsint enrichers and types: where definitions live, how the base class and vault work, and when a new type is warranted.

    9.3k GitHub stars~2.6k tokensUpdated 4 days ago
    DevelopmentAuto-check passed

More from CamusGIT/EvoQuant

  • Local Paper Navigator

    CamusGIT/EvoQuant

    Find and read papers from the local papers library (repo papers/, mounted at /papers/).

    151 GitHub stars~1.3k tokensUpdated 1 mo ago
    Auto-check passed
  • Quant Paper Extractor

    CamusGIT/EvoQuant

    Convert quantitative research report PDFs to markdown, then extract structured knowledge (paperId, title, year, source, keywords, tldr, abstract, strategy, method, experiment, result) into JSONL…

    151 GitHub stars~2.4k tokensUpdated 1 mo ago
    Auto-check passed
  • Paper Review

    CamusGIT/EvoQuant

    Guides self-review of YOUR OWN academic paper before submission with adversarial stress-testing.

    151 GitHub starsUsed in 2 repos~2.6k tokens
    Auto-check passed
  • Research Ideation

    CamusGIT/EvoQuant

    Quant-focused research ideation pipeline: scope selection (3 stages) → anchor-first literature grounding → single-core idea generation → iterative refinement → ELO tournament ranking (Final =…

    151 GitHub stars~5.4k tokensUpdated 1 mo ago
    Auto-check passed
  • Find Skills

    CamusGIT/EvoQuant

    Helps users discover agent skills from the open ecosystem. An agent skill from CamusGIT/EvoQuant.

    151 GitHub stars~595 tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Quant Experiment Runtime

What does Quant Experiment Runtime do?

Quant research experiment executor: discover an offline source database under the workdir's code-repo, build a panel, run a Research Artifact's entry point to compute research-object values, and…. Quant Experiment Runtime is an agent skill from CamusGIT/EvoQuant. Quant research experiment executor: discover an offline source database under the workdir's code-repo, build a panel, run a Research Artifact's entry point to compute research-object values, and evaluate IC/ICIR/RANKIC/coverage metrics.

When should I use Quant Experiment Runtime?

Quant Experiment Runtime fits situations like: : a research proposal is ready and you need to actually run the proposed factor/method on real data and get quantitative metrics; : designing which experiments to run (use experiment-pipeline / paper-planning); debugging a single failed experiment (use experiment-craft); searching papers (use local-paper-navigator).

How do I install Quant Experiment Runtime in Claude Code?

Run `npx skills add CamusGIT/EvoQuant --skill quant-experiment-runtime -a claude-code`. Or copy the skill folder (EvoQuant/skills/quant-experiment-runtime in CamusGIT/EvoQuant) into .claude/skills/quant-experiment-runtime in your project. Claude Code loads it when a task matches its description.

How do I install Quant Experiment Runtime in Codex?

Run `npx skills add CamusGIT/EvoQuant --skill quant-experiment-runtime -a codex`. Or copy the skill folder (EvoQuant/skills/quant-experiment-runtime in CamusGIT/EvoQuant) into .agents/skills/quant-experiment-runtime in your project. Codex loads it when a task matches its description.

Can I use Quant Experiment Runtime in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add CamusGIT/EvoQuant --skill quant-experiment-runtime -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/quant-experiment-runtime, .gemini/skills/quant-experiment-runtime, .github/skills/quant-experiment-runtime and .opencode/skills/quant-experiment-runtime in your project.

What does Quant Experiment Runtime need to run?

Going by SKILL.md and its folder, Quant Experiment Runtime needs Python for the scripts in its folder and the command-line tools its instructions call (python and docker). Our summary lists: Python 3; Docker. Its frontmatter pre-approves these tools: write_file, edit_file, read_file, think_tool, execute.

Does Quant Experiment Runtime access the network?

SKILL.md contains no URLs. Its commands use docker, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Quant Experiment Runtime safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Quant Experiment Runtime use?

Quant Experiment Runtime is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Quant Experiment Runtime use?

About 2.5k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.4k tokens, read only when the agent opens those files.

What are the alternatives to Quant Experiment Runtime?

Skills that share tags, products or a category with Quant Experiment Runtime: Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars), Merge Dependabot PRs (onyx-dot-app/onyx, 32k stars), Kedro Babysit (kedro-org/kedro, 11k stars) and LangBot Plugin Development (langbot-app/LangBot, 18k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Quant Experiment Runtime?

CamusGIT (a GitHub user) maintains it in CamusGIT/EvoQuant, which has 151 GitHub stars. The repository holds 6 skills in this directory. The repository was last updated on September 2, 2026.

Source: CamusGIT/EvoQuant on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.