New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Official agent skill

Autoresearch

by github in github/awesome-copilot

Autonomous iterative experimentation loop for any programming task.

OfficialMITAuto-check passedAgent Workflows

Install Autoresearch

skills CLI
$ npx skills add github/awesome-copilot --skill autoresearch -a claude-code

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

GitHub CLI
$ gh skill install github/awesome-copilot autoresearch --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/github/awesome-copilot.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/autoresearch .claude/skills/autoresearch && 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
autoresearch
GitHub stars
40k
Used in
2 other repos
Token cost
~2.8k tokens
SKILL.md length
1,085 words
Files
1
Skills in repo
417
Repo updated
First seen
Licence
MIT

At a glance

Autonomous iterative experimentation loop for any programming task.

  • Works in 4 steps: Setup (Interactive) → Branch & Baseline → Experiment Loop → …
  • : autonomous improvement
  • SKILL.md covers Agent Behavior Rules, Phase 1: Setup (Interactive), Phase 2: Branch & Baseline and Phase 3: Experiment Loop, plus 2 more sections
  • Calls git, dotnet and npm

What it does

Autoresearch is an agent skill from github/awesome-copilot, published by the product's own GitHub organization. Autonomous iterative experimentation loop for any programming task. Guides the user through defining goals, measurable metrics, and scope constraints, then runs an autonomous loop of code changes, testing, measuring, and keeping/discarding results. Inspired by Karpathy's autoresearch. USE FOR: autonomous improvement, iterative optimization, experiment loop, auto research, performance tuning, automated experimentation, hill climbing, try things automatically, optimize code, run experiments, autonomous coding loop…

Its SKILL.md is about 2.8k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts. Compatibility notes: Requires git. The project must be a git repository. Requires terminal access to run commands.

It sits in Agent Workflows, covering Autonomous loops and A/B testing. The repository describes itself as: Community-contributed instructions, agents, skills, and configurations to help you make the most of GitHub Copilot. The licence is MIT.

When your agent uses it

  • : autonomous improvement
  • Iterative optimization
  • Experiment loop
  • Performance tuning

Example prompts

  • “/autoresearch”

Requirements

  • Compatibility (from SKILL.md): Requires git. The project must be a git repository. Requires terminal access to run commands.

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. Setup (Interactive)
  2. Branch & Baseline
  3. Experiment Loop
  4. Reporting

What it can do on your machine

Read from SKILL.md and the folder at commit 727ff2e. 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

    Shell commands in SKILL.md call:

    • git
    • dotnet
    • npm
    • pytest

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

  • Network

    Links to these hosts (documentation or services it may open):

    • github.com

    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.

  • Compatibility

    Requires git. The project must be a git repository. Requires terminal access to run commands.

    From compatibility in the SKILL.md frontmatter.

Context cost

Autoresearch loads about 2.8k tokens when it runs. Until then it costs about 158 tokens; SKILL.md has 1,085 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~158
When it runs · the whole SKILL.md, loaded when a task matches
~2.8k

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); files beside SKILL.md are not scanned.

SKILL.md

The full file from github/awesome-copilot at commit 727ff2e, republished under its MIT licence (© github). 1,085 words, ~2,782 tokens.

Download SKILL.mdSave it as .claude/skills/autoresearch/SKILL.md (or your agent's skills folder).
name
autoresearch
description
Autonomous iterative experimentation loop for any programming task. Guides the user through defining goals, measurable metrics, and scope constraints, then runs an autonomous loop of code changes, testing, measuring, and keeping/discarding results. Inspired by Karpathy's autoresearch. USE FOR: autonomous improvement, iterative optimization, experiment loop, auto research, performance tuning, automated experimentation, hill climbing, try things automatically, optimize code, run experiments, autonomous coding loop. DO NOT USE FOR: one-shot tasks, simple bug fixes, code review, or tasks without a measurable metric.
compatibility
Requires git. The project must be a git repository. Requires terminal access to run commands.
license
MIT
metadata.author
luiscantero
metadata.inspired-by
https://github.com/karpathy/autoresearch

Autoresearch: Autonomous Iterative Experimentation

An autonomous experimentation loop for any programming task. You define the goal and how to measure it; the agent iterates autonomously -- modifying code, running experiments, measuring results, and keeping or discarding changes -- until interrupted.

This skill is inspired by Karpathy's autoresearch, generalized from ML training to any programming task with a measurable outcome.

Agent Behavior Rules

  1. DO guide the user through the Setup phase interactively before starting the loop.
  2. DO establish a baseline measurement before making any changes.
  3. DO commit every experiment attempt before running it (so it can be reverted cleanly).
  4. DO keep a results log (TSV) tracking every experiment.
  5. DO revert changes that do not improve the metric (git reset to last known good).
  6. DO run autonomously once the loop starts -- never pause to ask "should I continue?".
  7. DO NOT modify files the user marked as out-of-scope.
  8. DO NOT skip the measurement step -- every experiment must be measured.
  9. DO NOT keep changes that regress the metric unless the user explicitly allowed trade-offs.
  10. DO NOT install new dependencies or make environment changes unless the user approved it.

Phase 1: Setup (Interactive)

Before any experimentation begins, work with the user to establish these parameters. Ask the user directly for each item. Do not assume or skip any.

1.1 Define the Goal

Ask the user:

What are you trying to improve or optimize?

Examples: execution time, memory usage, binary size, test pass rate, code coverage, API response latency, throughput, error rate, benchmark score, build time, bundle size, lines of code, cyclomatic complexity, etc.

Record the user's answer as the goal.

1.2 Define the Metric

Ask the user:

How do we measure success? What exact command produces the metric?

I need:

  1. The command to run (e.g., dotnet test, npm run benchmark, time ./build.sh, pytest --tb=short)
  2. How to extract the metric from the output (e.g., a regex pattern, a specific line, a JSON field)
  3. Direction: Is lower better or higher better?

Example: "Run dotnet test --logger trx, count passing tests. Higher is better." Example: "Run hyperfine './my-program', extract mean time. Lower is better."

Record:

  • METRIC_COMMAND: the command to run
  • METRIC_EXTRACTION: how to extract the numeric metric from output
  • METRIC_DIRECTION: lower_is_better or higher_is_better
1.3 Define the Scope

Ask the user:

Which files or directories am I allowed to modify?

And which files are OFF LIMITS (read-only)?

Record:

  • IN_SCOPE_FILES: files/dirs the agent may edit
  • OUT_OF_SCOPE_FILES: files/dirs that must not be modified
1.4 Define Constraints

Ask the user:

Are there any constraints I should respect?

Examples:

  • Time budget per experiment (e.g., "each run should take < 2 minutes")
  • No new dependencies
  • Must keep all existing tests passing
  • Must not change the public API
  • Must maintain backward compatibility
  • VRAM/memory limit
  • Code complexity limits (prefer simpler solutions)

Record as CONSTRAINTS.

1.5 Define the Experiment Budget (Optional)

Ask the user:

How many experiments should I run, or should I just keep going until you stop me?

You can say a number (e.g., "try 20 experiments") or "unlimited" (I'll run until you interrupt).

Record as MAX_EXPERIMENTS (number or unlimited).

1.6 Simplicity Criterion

Inform the user of the default simplicity policy:

Simplicity policy (default): All else being equal, simpler is better. A small improvement that adds ugly complexity is not worth it. Removing code while maintaining or improving the metric is a great outcome. I'll weigh the complexity cost against the improvement magnitude. Does this policy work for you, or do you want to adjust it?

Record any adjustments as SIMPLICITY_POLICY.

1.7 Confirm Setup

Summarize all parameters back to the user in a clear table:

ParameterValue
Goal...
Metric command...
Metric extraction...
Directionlower is better / higher ...
In-scope files...
Out-of-scope files...
Constraints...
Max experiments...
Simplicity policy...

Ask the user to confirm. Do not proceed until confirmed.

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

Phase 2: Branch & Baseline

Once the user confirms:

  1. Create a branch: Propose a tag based on today's date (e.g., autoresearch/mar17). Create the branch: git checkout -b autoresearch/<tag>.

  2. Read in-scope files: Read all files that are in scope to build full context of the current state.

  3. Initialize results.tsv: Create results.tsv in the repo root with the header row:

    experiment	commit	metric	status	description

    Add results.tsv and run.log to .git/info/exclude (append if not already present) so they stay untracked without modifying any tracked files.

  4. Run the baseline: Execute the metric command on the current unmodified code. Record the result as experiment 0 with status baseline in results.tsv.

  5. Report baseline to the user:

    Baseline established: [metric_name] = [value] Starting autonomous experimentation loop.

Phase 3: Experiment Loop

Run this loop continuously. Do not stop to ask the user. Run until:

  • MAX_EXPERIMENTS is reached, OR
  • The user manually interrupts
For each experiment:
LOOP:
  1. THINK   - Analyze previous results and the current code.
               Generate an experiment hypothesis.
               Consider: what worked, what didn't, what hasn't been tried.

  2. EDIT    - Modify the in-scope file(s) to implement the idea.
               Keep changes focused and minimal per experiment.

  3. COMMIT  - git add + git commit with a short descriptive message.
               Format: "experiment: <short description of what changed>"

  4. RUN     - Execute the metric command.
               Redirect output to run.log so it does not flood the context window.
               Use shell-appropriate redirection:
               - Bash/Zsh: `<command> > run.log 2>&1`
               - PowerShell: `<command> *> run.log`

  5. MEASURE - Extract the metric from run.log.
               If extraction fails (crash/error), read the last 50 lines
               of run.log for the error.

  6. DECIDE  - Compare metric to the current best:
               - IMPROVED: Keep the commit. Update the "best" baseline.
                 Log status = "keep".
               - SAME OR WORSE: Revert. `git reset --hard HEAD~1`.
                 Log status = "discard".
               - CRASH: Attempt a quick fix (typo, import, simple error).
                 Amend the experiment commit (`git commit --amend`) with the fix
                 and rerun. The experiment keeps its original number.
                 If unfixable after 2 attempts, revert the entire experiment
                 (`git reset --hard HEAD~1`) and log status = "crash".

  7. LOG     - Append a row to results.tsv:
               experiment_number  commit_hash  metric_value  status  description

  8. CONTINUE - Go to step 1.
Experiment Strategy

When generating experiment ideas, follow this priority order:

  1. Low-hanging fruit first: Simple parameter tweaks, obvious inefficiencies.
  2. Informed by results: If a direction showed promise, explore further in that direction.
  3. Diversify after plateaus: If the last 3-5 experiments all failed, try a different approach entirely.
  4. Combine winners: If experiments A and B each improved independently, try combining them.
  5. Simplification passes: Periodically try removing code/complexity to see if the metric holds.
  6. Radical changes: After exhausting incremental ideas, try larger architectural changes.
Handling Constraints
  • Time budget: If a run exceeds 2x the expected duration, kill it and treat as a crash.
  • Existing tests: If constraints require tests to pass, run them before/after and revert if they break.
  • Memory/resources: Monitor and revert if resource usage exceeds stated limits.

Phase 4: Reporting

When the loop ends (budget reached or user interrupts):

  1. Print the full results.tsv as a formatted table.
  2. Summarize:
    • Total experiments run
    • Experiments kept / discarded / crashed
    • Starting metric (baseline) vs. final metric
    • Improvement percentage
    • Top 3 most impactful changes
  3. Show the cumulative git log of kept experiments: git log --oneline <start_commit>..HEAD
  4. Recommend next steps: Based on the results, suggest what a human researcher might try next (ideas that were too risky/complex for automated experimentation).

Quick Reference

Results TSV Format

Tab-separated, 5 columns:

experiment	commit	metric	status	description
0	a1b2c3d	0.997900	baseline	unmodified code
1	b2c3d4e	0.993200	keep	increase learning rate to 0.04
2	c3d4e5f	1.005000	discard	switch to GeLU activation
3	d4e5f6g	0.000000	crash	double model width (OOM)
Git Workflow
  • All experiments happen on the autoresearch/<tag> branch
  • Each experiment is committed before running
  • Failed experiments are reverted with git reset --hard HEAD~1
  • Successful experiments advance the branch
  • results.tsv and run.log stay untracked (added to .git/info/exclude)
Key Principles
  1. Measure everything: No experiment without a measurement.
  2. Revert failures: The branch only advances on improvements.
  3. Stay autonomous: Never stop to ask. Think harder if stuck.
  4. Keep it simple: Complexity is a cost. Weigh it against gains.
  5. Log everything: The TSV is the research journal.

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

Files

Just SKILL.md in skills/autoresearch of github/awesome-copilot.

Open the folder on GitHubat commit 727ff2e

Used in 2 other repositories

We found 2 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in github/awesome-copilot, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Autoresearch 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.

Autoresearch compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Autoresearch this skillgithub/awesome-copilot40k2 repos~2.8kAutomated safety check: PassMIT
KapsoLeeroo-AI/kapso120—~642Automated safety check: PassMIT
Spec Optimizeleo-kuang-ai/spec-first107—~13kAutomated safety check: PassMIT
Autoresearchgrandamenium/cortextos100—~1.9kAutomated safety check: PassMIT
Autoresearch Iteration Loopuditgoenka/autoresearch6.5k1 repos~2kAutomated safety check: PassMIT
Install Loop Engineeringcobusgreyling/loop-engineering11k1 repos~648Automated safety check: PassMIT

Similar skills

  • Kapso

    Leeroo-AI/kapso

    Optimize code using KAPSO (Knowledge-Grounded Optimization).

    120 GitHub stars~642 tokensUpdated today
    Agent WorkflowsAuto-check passed

  • Spec Optimize

    leo-kuang-ai/spec-first

    Run metric-driven iterative optimization loops. An agent skill from leo-kuang-ai/spec-first.

    107 GitHub stars~13k tokensUpdated 13 days ago
    AI & LLM EngineeringAuto-check passed

  • Autoresearch

    grandamenium/cortextos

    The analyst has assigned you a research cycle, or you have identified a metric you want to improve through systematic experimentation.

    100 GitHub stars~1.9k tokensUpdated 14 days ago
    Agent WorkflowsAuto-check passed

  • Autoresearch Iteration Loop

    uditgoenka/autoresearch

    Runs an autonomous modify, verify, keep-or-discard loop against any metric, with subcommands for planning, debugging, fixing, security audits, shipping and more.

    6.5k GitHub starsUsed in 1 repo~2k tokens
    Agent WorkflowsAuto-check passed

  • Install Loop Engineering

    cobusgreyling/loop-engineering

    Installs Loop Engineering into a project through the single @cobusgreyling/loop CLI, scaffolding a report-only loop and a readiness score.

    11k GitHub starsUsed in 1 repo~648 tokens
    Agent WorkflowsAuto-check passed

  • LoopX Self Repair

    loopx-project/loopx

    Diagnoses surprising LoopX behavior, such as stale recommendations or tiny progress, assigns it to the responsible layer and repairs it at the lowest durable level.

    6.2k GitHub stars~2.2k tokensUpdated today
    Agent WorkflowsAuto-check passed

More from github/awesome-copilot

All 417 skills in this repo

  • Acquire Codebase Knowledge

    github/awesome-copilot

    Official

    Maps an unfamiliar codebase into seven evidence-backed documents in docs/codebase/, using a scan script and templates, for onboarding or architecture write-ups.

    40k GitHub starsUsed in 1 repo~2.3k tokens
    Auto-check passed

  • Azure Architecture Autopilot

    github/awesome-copilot

    Official

    Designs Azure infrastructure from a natural-language description, or diagrams an existing resource group, then refines the design through conversation and deploys it with Bicep.

    40k GitHub starsUsed in 1 repo~1.9k tokens
    Auto-check passed

  • Draw.io Diagram Generator

    github/awesome-copilot

    Official

    Generates, edits and validates draw.io files with correct mxGraph XML, covering flowcharts, architecture, sequence, ER and UML class diagrams.

    40k GitHub starsUsed in 1 repo~4.9k tokens
    Auto-check passed

  • Credit Risk Data Cleaning

    github/awesome-copilot

    Official

    Cleans raw credit data and screens variables before loan modeling, dropping unstable, noisy or redundant features and writing an Excel report of every step.

    40k GitHub starsUsed in 1 repo~1.5k tokens
    Auto-check passed

  • Daily Focus Board

    github/awesome-copilot

    Official

    Builds a warm, browser-based daily focus board the user updates by talking to their agent, with Eisenhower priorities, a brain-dump box and kind not-today carryover.

    40k GitHub stars~3k tokensUpdated today
    Auto-check passed

  • Python Pypi Package Builder

    github/awesome-copilot

    Official

    End-to-end skill for building, testing, linting, versioning, and publishing a production-grade Python library to PyPI.

    40k GitHub starsUsed in 1 repo~4.6k tokens
    Auto-check passed

Categories

Questions about Autoresearch

What does Autoresearch do?

Autonomous iterative experimentation loop for any programming task. Autoresearch is an agent skill from github/awesome-copilot, published by the product's own GitHub organization. Autonomous iterative experimentation loop for any programming task.

When should I use Autoresearch?

Autoresearch fits situations like: : autonomous improvement; iterative optimization; experiment loop; performance tuning.

How do I install Autoresearch in Claude Code?

Run `npx skills add github/awesome-copilot --skill autoresearch -a claude-code`. Or copy the skill folder (skills/autoresearch in github/awesome-copilot) into .claude/skills/autoresearch in your project. Claude Code loads it when a task matches its description.

How do I install Autoresearch in Codex?

Run `npx skills add github/awesome-copilot --skill autoresearch -a codex`. Or copy the skill folder (skills/autoresearch in github/awesome-copilot) into .agents/skills/autoresearch in your project. Codex loads it when a task matches its description.

Can I use Autoresearch 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 github/awesome-copilot --skill autoresearch -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/autoresearch, .gemini/skills/autoresearch, .github/skills/autoresearch and .opencode/skills/autoresearch in your project.

What does Autoresearch need to run?

Going by SKILL.md and its folder, Autoresearch needs the command-line tools its instructions call (git, dotnet, npm and pytest). Compatibility (from SKILL.md): Requires git. The project must be a git repository. Requires terminal access to run commands..

Does Autoresearch access the network?

SKILL.md names 1 domain. As links in the text: github.com. This is read from the text; nothing was executed.

Is Autoresearch 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. Review the folder before installing.

What licence does Autoresearch use?

Autoresearch is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Autoresearch use?

About 2.8k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Autoresearch?

Skills that share tags, products or a category with Autoresearch: Kapso (Leeroo-AI/kapso, 120 stars), Spec Optimize (leo-kuang-ai/spec-first, 107 stars), Autoresearch (grandamenium/cortextos, 100 stars) and Autoresearch Iteration Loop (uditgoenka/autoresearch, 6.5k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Autoresearch?

github (a GitHub organization, an official publisher) maintains it in github/awesome-copilot, which has 39,748 GitHub stars. The repository holds 417 skills in this directory. The repository was last updated on October 7, 2026.

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