Ownmem Dashboard
grpcer/ownmem
Open OwnMem Console, the local dashboard for this repository's memory.
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…
$ npx skills add alibaba/atrex-kernel-agent --skill opt-trace-mining -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install alibaba/atrex-kernel-agent opt-trace-mining --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ 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-srcUse ~/.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/
Install the "opt-trace-mining" agent skill from https://github.com/alibaba/atrex-kernel-agent/tree/main/gpu-wiki/skills/opt-trace-mining into .claude/skills/opt-trace-mining/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "opt-trace-mining", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/alibaba/atrex-kernel-agent/tree/main/gpu-wiki/skills/opt-trace-miningType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add alibaba/atrex-kernel-agent --skill opt-trace-mining -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install alibaba/atrex-kernel-agent opt-trace-mining --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/alibaba/atrex-kernel-agent.git skills-src && mkdir -p .agents/skills && cp -r skills-src/gpu-wiki/skills/opt-trace-mining .agents/skills/opt-trace-mining && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "opt-trace-mining" agent skill from https://github.com/alibaba/atrex-kernel-agent/tree/main/gpu-wiki/skills/opt-trace-mining into .agents/skills/opt-trace-mining/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "opt-trace-mining", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add alibaba/atrex-kernel-agent --skill opt-trace-mining -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install alibaba/atrex-kernel-agent opt-trace-mining --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/alibaba/atrex-kernel-agent.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/gpu-wiki/skills/opt-trace-mining .cursor/skills/opt-trace-mining && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "opt-trace-mining" agent skill from https://github.com/alibaba/atrex-kernel-agent/tree/main/gpu-wiki/skills/opt-trace-mining into .cursor/skills/opt-trace-mining/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "opt-trace-mining", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/alibaba/atrex-kernel-agent.git --path gpu-wiki/skills/opt-trace-mining--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add alibaba/atrex-kernel-agent --skill opt-trace-mining -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install alibaba/atrex-kernel-agent opt-trace-mining --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/alibaba/atrex-kernel-agent.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/gpu-wiki/skills/opt-trace-mining .gemini/skills/opt-trace-mining && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "opt-trace-mining" agent skill from https://github.com/alibaba/atrex-kernel-agent/tree/main/gpu-wiki/skills/opt-trace-mining into .gemini/skills/opt-trace-mining/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "opt-trace-mining", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install alibaba/atrex-kernel-agent opt-trace-miningInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add alibaba/atrex-kernel-agent --skill opt-trace-mining -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/alibaba/atrex-kernel-agent.git skills-src && mkdir -p .github/skills && cp -r skills-src/gpu-wiki/skills/opt-trace-mining .github/skills/opt-trace-mining && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "opt-trace-mining" agent skill from https://github.com/alibaba/atrex-kernel-agent/tree/main/gpu-wiki/skills/opt-trace-mining into .github/skills/opt-trace-mining/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "opt-trace-mining", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add alibaba/atrex-kernel-agent --skill opt-trace-mining -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install alibaba/atrex-kernel-agent opt-trace-mining --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/alibaba/atrex-kernel-agent.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/gpu-wiki/skills/opt-trace-mining .opencode/skills/opt-trace-mining && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "opt-trace-mining" agent skill from https://github.com/alibaba/atrex-kernel-agent/tree/main/gpu-wiki/skills/opt-trace-mining into .opencode/skills/opt-trace-mining/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "opt-trace-mining", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
opt-trace-miningMine 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. 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.
3 steps, taken from the first numbered list in SKILL.md.
Read from SKILL.md and the folder at commit 3d27c1e. It shows what the files ask for, not the result of running them.
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.
Ships 14 files in scripts/ (Python), which the agent can run.
Shell commands in SKILL.md call:
python3From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
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.
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.
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.
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.
.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.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.
<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.
Nothing to configure for a trace that states its own hardware:
export RTM_TRACE=/path/to/your/trace/kernel_opt_001_your_operatoropt-trace-mining/<slug>/: parsed jsonl, packets. All
reproducible from the trace, so none of it is committed. Override with
RTM_WORKSPACE.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.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.
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.
| stage | deterministic output | what it will not do |
|---|---|---|
make_schema.py | assets/schema/opt-trace-1.0.schema.json, this corpus's narrowing of clean-1.3, from a declared patch list | invent a dialect: every patch only narrows, so passing the profile implies passing the store's schema |
ingest.py | one row per version: verdict, geomean, per-shape latency, correctness, DSL per commit, which captures are usable | guess hardware, or believe the version's self-reported commit hash |
recon.py | the evidence-density report: citable-number share, usable-capture share, what the live store already holds for this operator | decide anything; it exists so a human decides whether the trace is worth distilling |
long_horizon_recon.py | structured attempts, candidate lineages, and exact journal/commit attribution when long-horizon evidence exists | split one episode-level gain across experiments that lack their own measurement |
partition.py | one segment per record-to-be, with ids allocated above the store's existing maxima | judge whether a dead-end is a fact — it flags, the agent decides, the gate enforces |
build_packets.py | a scrubbed, self-contained packet per segment, plus the diff as a sibling file | let a raw identifier reach the layer the agent reads |
| (the agent) | one record per packet | write code, invent numbers, or fill a field the packet does not support |
validate_store.py | 17 gates and their injection tests | pass a record it cannot check against the trace |
score_records.py | worth.rank and the staging index.json, using the store's own wiki_score | let an agent score its own record |
make_readme.py | the reviewer's summary of the staging store | claim 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.
| segment | one record is | why |
|---|---|---|
| ratchet milestone | strategy | a version that set a new best-so-far. Carries code, so it needs a commit |
| dead-end | anti-strategy | one 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 pitfall | anti-strategy | mostly 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 snapshots | reference-kernel | the 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.
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.
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.
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:
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.wiki-gate derives it on insert. The store's ids gate checks the filename but
not the path.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.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.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.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.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.Never weaken a gate to make records pass, and never let a distilling agent edit
scripts/. When a gate looks wrong, prove it fires:
python3 validate_store.py --injection-testsEach 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.
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.
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:
gate.py --match --input <record.json> returns every same-scope candidate plus
any exact episode_key match. It makes no decision.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).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.
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.
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.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
SKILL.md and 16 other files (scripts, references, assets) in gpu-wiki/skills/opt-trace-mining of alibaba/atrex-kernel-agent.
Open the folder on GitHubat commit 3d27c1e
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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Opt Trace Mining this skillalibaba/atrex-kernel-agent | 154 | — | ~4.4k | Automated safety check: Pass | Apache-2.0 | |
| Ownmem Dashboardgrpcer/ownmem | 423 | — | ~563 | Automated safety check: Pass | Apache-2.0 | |
| Cc Update ReviewChachamaru127/claude-code-harness | 3.2k | — | ~1.6k | Automated safety check: Notes | MIT | |
| Gltf Asset Optimizationelodin-sys/elodin | 547 | — | ~1k | Automated safety check: Pass | Apache-2.0 | |
| Reliability ConcurrencyChatbotXIO/ChatbotX | 878 | — | ~735 | Automated safety check: Pass | Custom licence | |
| Agent Evalmajiayu000/claude-skill-registry | 666 | 4 repos | ~1k | Automated safety check: Notes | MIT |
grpcer/ownmem
Open OwnMem Console, the local dashboard for this repository's memory.
Chachamaru127/claude-code-harness
Quality guardrail for Claude/Codex update integration. An agent skill from Chachamaru127/claude-code-harness.
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.
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…
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
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
alibaba/atrex-kernel-agent
Mine AI coding-agent session transcripts into structured, gate-validated GPU-kernel optimization records for the wiki.
alibaba/atrex-kernel-agent
Choose and run ACU-only, adaptive PPU in-kernel timeline, or optional bounded joint analysis for a PPU kernel.
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…
alibaba/atrex-kernel-agent
Generate a structured implementation plan from an evidence draft.
alibaba/atrex-kernel-agent
Learn the target framework from enabled knowledge tools and implement a baseline GPU kernel.
alibaba/atrex-kernel-agent
Run the evidence loop of one long-horizon GPU kernel optimization episode.
Works with
Categories
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.