Agent skill

Opt Trace Mining

by alibaba in alibaba/atrex-kernel-agent

Mine a per-kernel optimization trace — a git repository capturing successive versions of one kernel being optimized — into structured, gate-validated optimization-experience records for the GPU…

Apache-2.0Auto-check passedAI & LLM Engineering

Install Opt Trace Mining

skills CLI
$ npx skills add alibaba/atrex-kernel-agent --skill opt-trace-mining -a claude-code

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

GitHub CLI
$ gh skill install alibaba/atrex-kernel-agent opt-trace-mining --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/alibaba/atrex-kernel-agent.git skills-src && mkdir -p .claude/skills && cp -r skills-src/gpu-wiki/skills/opt-trace-mining .claude/skills/opt-trace-mining && 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
opt-trace-mining
GitHub stars
154
Token cost
~4.4k tokens
SKILL.md length
2,179 words
Files
17 (incl. scripts, references, assets)
Skills in repo
7
Repo updated
First seen
Licence
Apache-2.0

At a glance

Mine a per-kernel optimization trace — a git repository capturing successive versions of one kernel being optimized — into structured, gate-validated optimization-experience records for the GPU…

  • Works in 3 steps: gate.py --match --input returns every… → The agent decides: no match → insert; a… → gate.py --commit executes it. insert…
  • Asked to distill an optimization run
  • SKILL.md covers Overview, What one trace looks like, Setup and Pipeline, plus 6 more sections
  • Runs Python scripts from its folder; calls python3

What it does

Opt Trace Mining is an agent skill from alibaba/atrex-kernel-agent. Mine a per-kernel optimization trace — a git repository capturing successive versions of one kernel being optimized — into structured, gate-validated optimization-experience records for the GPU kernel wiki. Use when asked to distill an optimization run, a kernelopt trace directory or a version ladder into wiki records; to report what such a run actually achieved; to build, extend, re-run or validate the staging store behind those records; or to explain how a trace-derived record's number, snippet or provenance…

Its SKILL.md is about 4.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 20 other files, including scripts, reference files and assets (for example `assets/schema/opt-trace-1.0.schema.json`, `references/distill-brief.md` and `scripts/anonymize.py`).

It sits in AI & LLM Engineering. It works with Git. The repository describes itself as: An end-to-end agent project for GPU kernel implementation, analysis, profiling, and iterative optimization. It helps an agent turn PyTorch logic or an existing kernel into a… The licence is Apache-2.0.

When your agent uses it

  • Asked to distill an optimization run
  • A kernelopt trace directory
  • A version ladder into wiki records
  • Report what such a run actually achieved

Example prompts

  • “/opt-trace-mining”

Requirements

  • Python 3

Workflow steps

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

  1. gate.py --match --input returns every same-scope candidate plus
  2. The agent decides: no match → insert; a match pointing the same way →
  3. gate.py --commit executes it. insert re-runs the store's

What it can do on your machine

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

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

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

    Shell commands in SKILL.md call:

    • python3

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

  • Network

    No URLs in SKILL.md.

    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

Opt Trace Mining loads about 4.4k tokens when it runs, and up to ~6.9k if it reads all its reference files. Until then it costs about 138 tokens; SKILL.md has 2,179 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~138
When it runs · the whole SKILL.md, loaded when a task matches
~4.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.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 alibaba/atrex-kernel-agent at commit 3d27c1e, republished under its Apache-2.0 licence (© alibaba). 2,179 words, ~4,448 tokens.

Download SKILL.mdSave it as .claude/skills/opt-trace-mining/SKILL.md (or your agent's skills folder). This skill also uses 16 other files; get the full folder from GitHub.
name
opt-trace-mining
description
Mine a per-kernel optimization trace — a git repository capturing successive versions of one kernel being optimized — into structured, gate-validated optimization-experience records for the GPU kernel wiki. Use when asked to distill an optimization run, a kernel_opt trace directory or a version ladder into wiki records; to report what such a run actually achieved; to build, extend, re-run or validate the staging store behind those records; or to explain how a trace-derived record's number, snippet or provenance was established.

Optimization Trace Mining

Overview

Turns one optimization trace into clean-1.3 records: one record per change that measurably moved a metric, and one per failed lever that turned out to be a fact. Each record answers which operator, what was wrong, what changed, why it worked at the machine level, the verbatim code, and how much it bought.

The pipeline is split the way its sibling session-trace-mining is: scripts do deterministic extraction, an agent does semantic distillation, and mechanical gates catch fabrication. The gates are why the output can be trusted. A model filling fields is the weak link, so nothing enters the store that cannot be checked against the trace.

What makes this corpus different from the sibling's: the trace is a git repository, so every claim can be re-resolved. Provenance is the trace label plus the commit, and the code is a real diff. The canonical version event is the commit that first adds memory/v<N>.json; this supports both legacy v<N>: commits and long-horizon promotion commits. A later metadata-only commit cannot replace that code-bearing event. There is no markdown page anywhere in this repository, so a record cites the trace and the commit and nothing else — records are the only source of truth here.

What one trace looks like

<trace>/.git                     canonical version events and code history
<trace>/kernel.py                the kernel at that commit
<trace>/memory/v<N>.json         per-version measurements       (optional)
<trace>/profiles/v<N>*/          profiler captures              (optional)
<trace>/versions/kernel_v<N>.py  kept-version snapshots         (optional)
<trace>/definition.json          operator name and axes         (optional)
<trace>/solution.json            target hardware, languages     (optional)
<trace>/workload.jsonl           one line per benchmarked shape (optional)

Only .git is required, and each missing piece removes exactly one capability: no memory/ means no numbers, hence no strategy records; no profiles/ means no record may ever claim a profiler-backed bottleneck. The three sources disagree, so each is read only for what it is authoritative about — commits for the code/version event, step records for measurements and terminal outcome, captures for the bottleneck.

Setup

Nothing to configure for a trace that states its own hardware:

bash
export RTM_TRACE=/path/to/your/trace/kernel_opt_001_your_operator
  • scratch — the platform temporary directory under opt-trace-mining/<slug>/: parsed jsonl, packets. All reproducible from the trace, so none of it is committed. Override with RTM_WORKSPACE.
  • staging — kernel_wiki/staging/: records plus reports/<slug>/. Reviewed, then promoted. Override with RTM_STORE.

Configure before the first run:

  • config.TRACES holds ONE clearly fictional example entry. Either point RTM_TRACE at your own trace or register it there. The entry supplies the measurement target when the trace itself does not state it.
  • hardware: ingest.py reads solution.json / definition.json and maps the token through config.TARGET_TABLE. If it finds nothing and no RTM_ARCH / RTM_PRODUCT is set, it fails rather than guessing — a record filed under hardware nobody measured is worse than no record, because the store's scope filter will serve it to an agent on different hardware.
  • config.NON_TARGET_KERNELS lists kernel names a profiler capture may not be about. The default is torch's RNG fill, which is what ncu grabs when no --kernel-name filter was passed. Add your harness's own kernels (RTM_NON_TARGET_KERNELS).
  • ATREX_WIKI_DENYLIST (optional) points at a file of private substrings, one per line, scrubbed out of packets and rejected by the store's own gate. It is an environment variable and not a committed list on purpose: a committed denylist publishes the names it is meant to hide.

jsonschema is needed for the two schema gates; without it they SKIP loudly.

Pipeline

bash
S=<skill-dir>/scripts
G=<skill-dir>/../wiki-gate/scripts/gate.py
export RTM_TRACE=/path/to/trace

python3 $S/make_schema.py --check     # the profile matches its patch list
python3 $S/ingest.py                  # trace  -> work/versions.jsonl, profiles.jsonl, meta.json
python3 $S/recon.py                   #        -> reports/<slug>/recon.md   READ THIS FIRST
python3 $S/long_horizon_recon.py      #        -> reports/<slug>/long-horizon.md when present
python3 $S/partition.py               #        -> work/segments.jsonl, reports/<slug>/partition.md
python3 $S/build_packets.py           #        -> packets/<seg>.{json,diff,py}
# distil (see below), then:
python3 $S/validate_store.py --verbose        # 9 store gates + 8 trace gates
python3 $S/validate_store.py --injection-tests
python3 $S/score_records.py           # worth.rank + records/index.json
python3 $S/make_readme.py             #        -> <staging>/README.md
# then, per record, the admission gate:
python3 $G --match  --input <record.json>
python3 $G --commit insert --input <record.json>

Re-run the last three after every distillation batch.

What each stage does, and what it refuses to decide
stagedeterministic outputwhat it will not do
make_schema.pyassets/schema/opt-trace-1.0.schema.json, this corpus's narrowing of clean-1.3, from a declared patch listinvent a dialect: every patch only narrows, so passing the profile implies passing the store's schema
ingest.pyone row per version: verdict, geomean, per-shape latency, correctness, DSL per commit, which captures are usableguess hardware, or believe the version's self-reported commit hash
recon.pythe evidence-density report: citable-number share, usable-capture share, what the live store already holds for this operatordecide anything; it exists so a human decides whether the trace is worth distilling
long_horizon_recon.pystructured attempts, candidate lineages, and exact journal/commit attribution when long-horizon evidence existssplit one episode-level gain across experiments that lack their own measurement
partition.pyone segment per record-to-be, with ids allocated above the store's existing maximajudge whether a dead-end is a fact — it flags, the agent decides, the gate enforces
build_packets.pya scrubbed, self-contained packet per segment, plus the diff as a sibling filelet a raw identifier reach the layer the agent reads
(the agent)one record per packetwrite code, invent numbers, or fill a field the packet does not support
validate_store.py17 gates and their injection testspass a record it cannot check against the trace
score_records.pyworth.rank and the staging index.json, using the store's own wiki_scorelet an agent score its own record
make_readme.pythe reviewer's summary of the staging storeclaim the records are in the store

Read reports/<slug>/recon.md before distilling. It decides what the product can honestly be: how many milestones carry a geomean (only those may claim basis=measured), how many captures measured the kernel under test (only those may back a bottleneck), and what the store already covers. A trace with almost no numbers still has value as mechanism and anti-patterns — do not force a gain claim onto every record.

What a segment becomes

segmentone record iswhy
ratchet milestonestrategya version that set a new best-so-far. Carries code, so it needs a commit
dead-endanti-strategyone per failed lever, not one per reverted commit. A single reverted commit routinely lists three unrelated failures; keeping them together produces a record that matches three queries and answers none
curated pitfallanti-strategymostly hangs off kept versions: the run shipped the change and separately wrote down what had not worked. The reverted path cannot see this knowledge
final kernel, mega snapshotsreference-kernelthe whole implementation, for reading rather than for a delta

The terminal reference is the newest code-bearing, non-reverted version with a positive complete measurement and explicit PASS correctness and quality-gate results. A newer unmeasured, failed, or reverted commit cannot displace it.

A trace cannot produce a technique-card (a cross-corpus aggregate) or a doc (no measurement), and cannot produce a generic-level record: one kernel's measurement is not evidence for every architecture. The profile enforces all three.

Long-horizon deep pass

When .atrex_long_horizon/ or memory/long_horizon_e*.json exists, run long_horizon_recon.py after recon.py and read both reports before distilling. The deep pass may produce one granular strategy only when a structured attempt binds its own retained code commit, measurement, and correctness result. It may produce a granular anti-strategy only when a rejected or null experiment clears the established-fact bar. Research, planning, diagnostics without a conclusion, and policy-rejected candidates must not be presented as successful strategies.

Granular records carry evidence.raw.evidence_extra with the journal path, experiment ids, and a resolvable canonical or revalidation commit. Local or archived A/B measurements remain provisional unless supervisor verification explicitly marks the candidate measurement authoritative. Legacy free-form journals require semantic review; never assign an episode-level gain to every probe or commit.

Why only a ratchet

A legacy trace's latency series is not a progress curve, so ladder.py selects only versions that set a new best-so-far. A long-horizon record may instead carry an authoritative candidate improvement from same-allocation supervisor verification; that explicit value takes precedence over cross-episode geomeans. A metadata-only version may update the observed floor but cannot own a strategy. python3 ladder.py pins the ratchet on a synthetic non-monotonic series.

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

The seventeen gates

validate_store.py runs this repository's own tools/check_kernel_wiki.py against the staging root, so all nine of its gates apply — schema · ids · anonymization · raw-isolation · relations · index · self-contained · no-cross-reference · established-fact — and then eight that only this pipeline can run, because only it has the trace and the packets:

  • profile — the record satisfies opt-trace-1.0, which additionally requires the trace provenance triple, measured_on, gain.kind, and established_fact on every anti-strategy, and closes evidence.raw so a dead path cannot be reintroduced.
  • layout — the directory equals the record's own scope, derived exactly as wiki-gate derives it on insert. The store's ids gate checks the filename but not the path.
  • verbatim — implementation.snippet must appear literally in the packet's sibling diff or kernel file. The gate and the distiller read the same file on purpose. Compared line by line, so a snippet assembled from two hunks passes.
  • no-fabrication — every number in payload, worth.gain, evidence.summary and retrieval.signals.metrics must appear in the packet or in its code. Code-ish fields are exempt because they are verbatim source.
  • provenance — evidence.raw must name this trace, and its git_commit must resolve to a commit in it. This is the whole of a record's auditability once the packets are deleted.
  • ncu-attribution — a basis=profiler claim must cite a capture that measured the kernel under test. A capture taken without a --kernel-name filter is schema-valid and describes the wrong kernel, so it is actively misleading rather than merely empty; without this gate such a record looks well-evidenced.
  • store-overlap — the id must still be free in the live store, because wiki-gate --commit insert refuses a duplicate and renumbering after a batch is the expensive part. An episode_key that already exists is reported, not failed: whether it is a rediscovery to confirm is the agent's judgement.
  • journal-provenance — a granular long-horizon record must cite an existing journal or archived evidence file, every declared experiment id must occur in it, and its canonical promotion or revalidation commit must resolve. Evidence paths must be relative to the trace root; absolute paths, traversal, symlink escapes, files above 8 MiB, and aggregate evidence above 32 MiB are rejected before content is read.

Never weaken a gate to make records pass, and never let a distilling agent edit scripts/. When a gate looks wrong, prove it fires:

bash
python3 validate_store.py --injection-tests

Each case mutates a copy of a real record — and, where the error lives there, its packet — and asserts the named gate complains. A gate without an injection test is how a store ends up falsely green.

One gate the predecessor had is deliberately gone: it checked that every record cited an existing markdown page. This repository has no markdown tree, so that gate could only be satisfied by writing a citation to a file that does not exist. Provenance replaced it.

Distillation

Spawn agents with references/distill-brief.md verbatim. Batch by record type so a failure has a small blast radius, and point every agent at the one record that already passes as the worked example.

Require each agent to run validate_store.py itself and iterate to green, and to report which fields the packet was too thin to fill and which gate blocked it. That report is the main signal for improving the pipeline; treat a batch that reports no difficulties with suspicion. When several agents write into one staging store concurrently, tell them explicitly to ignore gate failures naming records they do not own.

An anti-strategy segment whose evidence names neither a checkable condition nor a cause must not be written up at all. partition.py marks those with fact_precheck, but the flag is a hint, not a verdict: a regex must narrow and never judge, so it also flags genuine facts whose wording is unusual, and the agent resolves it from the packet's own evidence.

How a record reaches the store

skills/wiki-gate is the only writer into kernel_wiki/records/. Nothing this skill produces is served until it has been through the gate, whatever its own gates say:

  1. gate.py --match --input <record.json> returns every same-scope candidate plus any exact episode_key match. It makes no decision.
  2. The agent decides: no match → insert; a match pointing the same way → confirm (bumps the existing record's counters, idempotently); a match pointing the opposite way → conflict (queued for a human, exit 0).
  3. gate.py --commit <action> executes it. insert re-runs the store's record-level gates, refuses an id that already exists, writes the record under records/<type>/<vendor>/<arch>/<dsl>/<operator_family>/ and appends the index entry.

A record rejected by the gate stays in staging. It is not deleted: once it gains the condition and the mechanism it lacked, or is independently rediscovered, it can go through again.

Porting to another trace archive

Everything is trace-agnostic except three places:

  • config.py — TRACES (where your traces live and what hardware they ran on), TARGET_TABLE (hardware token → vendor/arch/product), and NON_TARGET_KERNELS.
  • families.py — operator naming: raw directory name → record slug and workload family. This is the only file that decides where a record is filed, so it is self-contained and self-tested rather than shared: a change in another tree would silently refile records. python3 families.py checks the slug rules and that every family it can emit is still a value the schema allows.
  • ingest.py — the only file that knows how a trace is shaped. A different layout means adapting read_commits / read_memory / read_profiles; everything downstream sees version rows and never a raw file.

Two things to check on a new archive before trusting the output: whether every canonical memory/v<N>.json addition can be paired with the intended kernel state (legacy subject-only traces use v<N>: as fallback), and what fraction of profiler captures measured the kernel under test — recon.py prints both.

Resources

  • references/distill-brief.md — the agent brief. Pass it verbatim.
  • assets/schema/opt-trace-1.0.schema.json — the corpus profile, generated by make_schema.py; run it with --show to read the patch list and the reason for each patch.
  • skills/wiki-gate/references/established-fact-criteria.md — the normative admission bar for negative knowledge; partition.py imports the same regexes the store's gate uses, so triage and enforcement cannot disagree.
  • Self-tests worth running after any edit: python3 families.py, python3 ladder.py, python3 anonymize.py, plus the repository's existing query and Wiki validation suites.

© alibaba, 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 16 other files (scripts, references, assets) in gpu-wiki/skills/opt-trace-mining of alibaba/atrex-kernel-agent.

  • SKILL.md
  • assets/schema/opt-trace-1.0.schema.json
  • references/distill-brief.md
  • scripts/anonymize.py
  • scripts/build_packets.py
  • scripts/check_anonymized.py
  • scripts/config.py
  • scripts/families.py
  • scripts/ingest.py
  • scripts/ladder.py
  • scripts/long_horizon_recon.py
  • scripts/make_readme.py
  • scripts/make_schema.py
  • scripts/partition.py
  • scripts/recon.py
  • scripts/score_records.py
  • scripts/validate_store.py

Open the folder on GitHubat commit 3d27c1e

Compare with similar skills

Opt Trace Mining 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.

Opt Trace Mining compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Opt Trace Mining this skillalibaba/atrex-kernel-agent154—~4.4kAutomated safety check: PassApache-2.0
Ownmem Dashboardgrpcer/ownmem423—~563Automated safety check: PassApache-2.0
Cc Update ReviewChachamaru127/claude-code-harness3.2k—~1.6kAutomated safety check: NotesMIT
Gltf Asset Optimizationelodin-sys/elodin547—~1kAutomated safety check: PassApache-2.0
Reliability ConcurrencyChatbotXIO/ChatbotX878—~735Automated safety check: PassCustom licence
Agent Evalmajiayu000/claude-skill-registry6664 repos~1kAutomated safety check: NotesMIT

Similar skills

  • Ownmem Dashboard

    grpcer/ownmem

    Open OwnMem Console, the local dashboard for this repository's memory.

    423 GitHub stars~563 tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed
  • Cc Update Review

    Chachamaru127/claude-code-harness

    Quality guardrail for Claude/Codex update integration. An agent skill from Chachamaru127/claude-code-harness.

    3.2k GitHub stars~1.6k tokensUpdated 2 days ago
    AI & LLM EngineeringAuto-check: notes
  • Gltf Asset Optimization

    elodin-sys/elodin

    Reduce the size of glTF/GLB 3D assets to cut Git LFS bandwidth/storage while keeping them loadable by the editor's Bevy 0.18 glTF loader.

    547 GitHub stars~1k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Reliability Concurrency

    ChatbotXIO/ChatbotX

    A skill your agent uses when writing code that runs concurrently in ChatbotX — BullMQ worker consumers, sharded DB migrations, embedding replace-writes, or any multi-step operation that could be…

    878 GitHub stars~735 tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Agent Eval

    majiayu000/claude-skill-registry

    Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics

    666 GitHub starsUsed in 4 repos~1k tokens
    AI & LLM EngineeringAuto-check: notes
  • Cco Pack

    egorfedorov/claude-context-optimizer

    Build an optimal context pack for the user's task — ranked file list with offset/limit suggestions, based on git state, mentioned paths, and historical patterns

    114 GitHub stars~448 tokensUpdated 7 days ago
    AI & LLM EngineeringAuto-check passed

More from alibaba/atrex-kernel-agent

  • Session Trace Mining

    alibaba/atrex-kernel-agent

    Mine AI coding-agent session transcripts into structured, gate-validated GPU-kernel optimization records for the wiki.

    154 GitHub stars~3.1k tokensUpdated 8 days ago
    Auto-check passed
  • Ppu Acu Joint Profile

    alibaba/atrex-kernel-agent

    Choose and run ACU-only, adaptive PPU in-kernel timeline, or optional bounded joint analysis for a PPU kernel.

    154 GitHub stars~5.2k tokensUpdated 8 days ago
    Auto-check passed
  • Autonomous GPU Kernel Timeline

    alibaba/atrex-kernel-agent

    Let AKA autonomously add, run, inspect, and revise intra-kernel timeline probes for standalone CUDA/inline PTX or CuTe DSL when ordinary benchmark, NSYS, or NCU evidence cannot answer a specific…

    154 GitHub stars~1.3k tokensUpdated 8 days ago
    Auto-check passed
  • Gen Plan

    alibaba/atrex-kernel-agent

    Generate a structured implementation plan from an evidence draft.

    154 GitHub stars~3.4k tokensUpdated 8 days ago
    Auto-check passed
  • GPU Kernel Baseline

    alibaba/atrex-kernel-agent

    Learn the target framework from enabled knowledge tools and implement a baseline GPU kernel.

    154 GitHub stars~2.1k tokensUpdated 8 days ago
    Auto-check passed
  • GPU Kernel Episode Loop

    alibaba/atrex-kernel-agent

    Run the evidence loop of one long-horizon GPU kernel optimization episode.

    154 GitHub stars~3.6k tokensUpdated 8 days ago
    Auto-check passed

Works with

Questions about Opt Trace Mining

What does Opt Trace Mining do?

Mine a per-kernel optimization trace — a git repository capturing successive versions of one kernel being optimized — into structured, gate-validated optimization-experience records for the GPU…. Opt Trace Mining is an agent skill from alibaba/atrex-kernel-agent. Mine a per-kernel optimization trace — a git repository capturing successive versions of one kernel being optimized — into structured, gate-validated optimization-experience records for the GPU kernel wiki.

When should I use Opt Trace Mining?

Opt Trace Mining fits situations like: asked to distill an optimization run; A kernelopt trace directory; A version ladder into wiki records; report what such a run actually achieved.

How do I install Opt Trace Mining in Claude Code?

Run `npx skills add alibaba/atrex-kernel-agent --skill opt-trace-mining -a claude-code`. Or copy the skill folder (gpu-wiki/skills/opt-trace-mining in alibaba/atrex-kernel-agent) into .claude/skills/opt-trace-mining in your project. Claude Code loads it when a task matches its description.

How do I install Opt Trace Mining in Codex?

Run `npx skills add alibaba/atrex-kernel-agent --skill opt-trace-mining -a codex`. Or copy the skill folder (gpu-wiki/skills/opt-trace-mining in alibaba/atrex-kernel-agent) into .agents/skills/opt-trace-mining in your project. Codex loads it when a task matches its description.

Can I use Opt Trace Mining 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 alibaba/atrex-kernel-agent --skill opt-trace-mining -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/opt-trace-mining, .gemini/skills/opt-trace-mining, .github/skills/opt-trace-mining and .opencode/skills/opt-trace-mining in your project.

What does Opt Trace Mining need to run?

Going by SKILL.md and its folder, Opt Trace Mining needs Python for the scripts in its folder and the command-line tools its instructions call (python3). Our summary lists: Python 3.

Does Opt Trace Mining access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Opt Trace Mining 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 Opt Trace Mining use?

Opt Trace Mining 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 Opt Trace Mining use?

About 4.4k tokens (SKILL.md is roughly 18k 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 2.5k tokens, read only when the agent opens those files.

What are the alternatives to Opt Trace Mining?

Skills that share tags, products or a category with Opt Trace Mining: Ownmem Dashboard (grpcer/ownmem, 423 stars), Cc Update Review (Chachamaru127/claude-code-harness, 3.2k stars), Gltf Asset Optimization (elodin-sys/elodin, 547 stars) and Reliability Concurrency (ChatbotXIO/ChatbotX, 878 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Opt Trace Mining?

alibaba (a GitHub organization) maintains it in alibaba/atrex-kernel-agent, which has 154 GitHub stars. The repository holds 7 skills in this directory. The repository was last updated on September 29, 2026.

Source: alibaba/atrex-kernel-agent on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.