awesome-autoresearch

KO | EN

gitlite — search

#typescript #ai-agents #ai #dsh-plugin #deepseek-harness #open-source #cli #claude-code #codex #developer-tools #react #windows

awesome-autoresearch

★ 686 Open GitHub ↗

awesome autoresearch list

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# awesome-autoresearch

A curated awesome list of public autoresearch use cases across industries.

This README is the homepage aggregate of the current category files, so the latest accepted entries are visible here without drilling into subpages.

The repository treats all categories equally — each entry lives in exactly one category, chosen by its direct autoresearch application domain. A dedicated **Related Practices / Discussions** category captures credible public practice signals — X threads, Reddit discussions, and interviews — that describe real autoresearch usage even when no strong standalone case page exists yet.

## Why this list

Most discussions about autoresearch are still scattered, vague, or overly tool-centric. This list is designed to answer two practical questions quickly:

- Where has autoresearch already been used in real workflows?
- Which patterns can transfer across industries?

This is not a comprehensive database. It is a high-signal, fast-scanning field guide.

## Inclusion criteria

An entry should meet all of the following:

- The source is public and citable.
- The example is **directly related to autoresearch**, not just a generic research or monitoring agent.
- The source explicitly mentions `autoresearch`, cites Karpathy's autoresearch, or clearly shows a modify → verify → keep/discard → repeat loop.
- The summary explains the scenario, method, and value in one sentence.

We do **not** include:

- Generic research agents, monitoring agents, or multi-agent systems with no explicit autoresearch loop.
- Pure theory or opinion without a concrete practice.
- Generic AI commentary with no autoresearch workflow.
- Long write-ups inside the list itself.
- Sources that are private, inaccessible, or too vague to classify.

## Current coverage

- [Scientific Research](categories/scientific-research.md) — 83 entries
- [Software / Systems Optimization](categories/software-systems-optimization.md) — 52 entries
- [Evaluation / Red Teaming](categories/evaluation-red-teaming.md) — 24 entries
- [Finance / Trading](categories/finance-trading.md) — 33 entries
- [Personal Knowledge / Humanities](categories/personal-knowledge-humanities.md) — 2 entries
- [Knowledge Base / RAG Preparation](categories/knowledge-base-rag-preparation.md) — 2 entries
- [Market Research](categories/market-research.md) — 0 entries
- [Workflow Automation](categories/workflow-automation.md) — 4 entries
- [Infra / Skills / Forks](categories/infra-skills-forks.md) — 150 entries
- [Related Practices / Discussions](categories/related-practices-discussions.md) — 164 entries

### Open categories still being seeded

- [Competitive Intelligence](categories/competitive-intelligence.md) — 0 entries
- [Content Research](categories/content-research.md) — 0 entries
- [Customer Discovery](categories/customer-discovery.md) — 0 entries
- [Lead Generation](categories/lead-generation.md) — 0 entries
- [Trend Monitoring](categories/trend-monitoring.md) — 0 entries

Each entry lives in exactly one category. When a project could fit multiple categories, we choose the one closest to its direct application domain.

## Browse by category

- [Scientific Research](#scientific-research) ([source](categories/scientific-research.md))
- [Software / Systems Optimization](#software-systems-optimization) ([source](categories/software-systems-optimization.md))
- [Evaluation / Red Teaming](#evaluation-red-teaming) ([source](categories/evaluation-red-teaming.md))
- [Finance / Trading](#finance-trading) ([source](categories/finance-trading.md))
- [Personal Knowledge / Humanities](#personal-knowledge-humanities) ([source](categories/personal-knowledge-humanities.md))
- [Knowledge Base / RAG Preparation](#knowledge-base-rag-preparation) ([source](categories/knowledge-base-rag-preparation.md))
- [Workflow Automation](#workflow-automation) ([source](categories/workflow-automation.md))
- [Infra / Skills / Forks](#infra-skills-forks) ([source](categories/infra-skills-forks.md))
- [Related Practices / Discussions](#related-practices-discussions) ([source](categories/related-practices-discussions.md))

## Full list

### Scientific Research

Source file: [`categories/scientific-research.md`](categories/scientific-research.md)

- [SAGE](https://github.com/JieMaMagic/SAGE) - Scientific research: applies an autonomous research loop to scientific experiments by generating multiple causal explanations for failures, verifying the true root cause to modify the code or design, and keeping successful interventions to increase reliable metrics-bearing outputs.
- [AutoResearchClaw](https://github.com/aiming-lab/AutoResearchClaw) - Scientific research: turns a research idea into a paper through a fully autonomous multi-stage pipeline with self-healing experiments and pivot/refine loops.
- [Sibyl Research System](https://github.com/Sibyl-Research-Team/AutoResearch-SibylSystem) - Scientific research: builds a fully autonomous AI scientist on Claude Code with inner research-iteration loops and outer self-evolution across projects.
- [EurekAgent](https://github.com/THU-Team-Eureka/EurekAgent) - Scientific research: runs metric-driven autoresearch with Claude Code sessions, introducing agent environment engineering through bounded execution, isolated evaluation, Git-backed artifacts, budget controls, and human oversight, setting new SOTA on three mathematics optimization tasks at under $17 average API cost, reaching top GPUMODE kernel-engineering results, and ranking first by medal rate on an MLE-Bench subset.
- [autoresearch-rl](https://github.com/vivekvkashyap/autoresearch-rl) - RL research: applies the autoresearch pattern to RL post-training by iterating on one training config, running fixed-time experiments, and keeping only eval improvements.
- [autoresearch-robotics](https://github.com/jellyheadandrew/autoresearch-robotics) - Robotics research: adapts Karpathy-style autoresearch to MuJoCo and Gymnasium robotics tasks by editing one training file, evaluating fixed-budget runs, and using simulator renderings plus vision feedback to keep only better policies.
- [autoslam](https://github.com/pglira/autoslam) - LiDAR SLAM research: applies an autoresearch-style autonomous loop to LiDAR SLAM method design and evaluation on the KITTI odometry benchmark, accumulating a leaderboard over weeks through iterative keep/discard experiments.
- [Tinker-Explorer](https://github.com/mohammed840/autoresearch-explorer) - Evidence-retrieval research: adapts the autoresearch pattern to GRPO document exploration, comparing reward designs and keeping only retrieval policies that answer multihop questions more accurately under a token budget.
- [Autoresearch on an old research idea](https://ykumar.me/blog/eclip-autoresearch/) - Multimodal retrieval research: applies Claude Code autoresearch to an old eCLIP idea, running 42 fixed-budget experiments with commit/revert decisions and cutting mean rank from 344.68 to 157.43.
- [autoresearch-at-home](https://github.com/mutable-state-inc/autoresearch-at-home) - Distributed ML research: coordinates a SETI@home-style swarm of agents that claim experiments, share full `train.py` results through Ensue, and collectively drive down val_bpb across different GPUs.
- [autoresearch-paper-benchmark](https://github.com/roth-andreas/autoresearch-paper-benchmark) - Graph ML research: runs paper-driven campaigns on a fixed Peptides-func benchmark by editing `train.py`, logging 300-second experiments, and testing only the best validation-AP model at campaign end.
- [autoresearch-cifar10](https://github.com/GuillaumeErhard/autoresearch-cifar10) - Vision research: applies autoresearch to CIFAR-10 ResNet training on a 3090, iterating under fixed time budgets and keeping changes that lift accuracy beyond a 91.89% baseline.
- [autoresearch-yolo](https://github.com/Tuesdayyy/autoresearch-yolo) - Vision research: adapts Karpathy's one-file keep/revert loop to YOLOv8 on COCO128, editing only `train.py`, running 10-minute experiments, and raising `mAP50-95` from 0.3820 to 0.8303 in the published results ledger.
- [AutoResearch-GenPose](https://github.com/PeleWang/AutoResearch-GenPose) - Vision research: adapts autoresearch to CIFAR-10 UNet denoising by editing one training file, running fixed 5-minute experiments, and keeping only val_psnr improvements.
- [MLP-AutoResearch](https://github.com/HuangShengZeBlueSky/MLP_AutoResearch) - MNIST training research: ports Karpathy's single-file loop to an MLP classifier, fixing 20-epoch runs and greedy keep/revert decisions that raised handwritten-digit accuracy from 0.9809 to 0.9836.
- [autoresearch-medimage](https://github.com/mattlungrenmd/autoresearch-medimage) - Medical imaging research: adapts Karpathy's `prepare.py` + `train.py` + `results.tsv` loop to 2D imaging tasks, using short-budget candidate discovery and staged follow-up validation to surface stronger ChestXray14 models.
- [Agentic MR sequence development](https://arxiv.org/abs/2604.13282) - MRI sequence research: uses Agent4MR with physics-aware validation to let agents generate, refine, and autoresearch PyPulseq sequences for a fluid-suppressed spin-echo EPI challenge across model generations.
- [autocircuit](https://github.com/qelloman/autocircuit) - Analog circuit optimization: adapts Karpathy's autoresearch to a SKY130 two-stage op-amp, editing `optimize.py`, running ngspice, and keeping only parameter changes that expand the GBW-versus-power Pareto front under phase-margin constraints.
- [Photonic Device Auto-Design Agent](https://github.com/flexcompute/autophotonicdesign) - Photonic design research: applies a Karpathy-inspired loop to one `design.py`, running layout previews, fabrication DRC, FDTD simulations, and keep/discard decisions to optimize devices such as splitters, tapers, and crossings.
- [fe-autoresearch](https://github.com/ezemriv/fe-autoresearch) - Tabular ML research: applies the autoresearch loop to LightGBM feature engineering on the UCI Bank Marketing dataset by editing one `engineer_features()` target, training against fixed AUC metrics, and keeping only improvements.
- [AutoFeaTune](https://github.com/PranavBedi11/AutoFeaTune) - Tabular ML research: edits only `features.py`, trains XGBoost under 5-fold CV composite scoring, and uses a git ratchet plus graph memory to keep or revert feature transforms over repeated autoresearch runs.
- [Paper Lantern improves Autoresearch](https://www.paperlantern.ai/blog/auto-research-case-study) - ML research augmentation: connects a 2M-paper MCP server to autoresearch, letting the agent cite 100 papers across 100 experiments and reach a 3.2% lower 2-hour validation loss than the same run without paper access.
- [Subtractive Search in a Mature Tabular Pipeline](https://github.com/jhamandeep/autoresearch-tabular-case-study) - Tabular ML research: applies Karpathy's autoresearch to a churn-prediction XGBoost pipeline, running 116 autonomous experiments and lifting subsample AUC from 0.902892 to 0.916721 largely by removing noisy target-encoded features.
- [autoresearch-connect4](https://github.com/alessoh/autoresearch-connect4) - Game AI research: adapts Karpathy's three-file autoresearch loop to Connect Four by editing `train.py`, training 5-minute self-play runs, and keeping only changes that improve weighted win rate against fixed opponents.
- [autoresearch-tabular](https://github.com/saikatkumardey/autoresearch-tabular) - Tabular ML research: adapts Karpathy's three-file loop to the Adult Income benchmark by editing only `train.py`, running fixed 2-minute experiments, and keeping only `val_auc` improvements.
- [ocr-autoresearch](https://github.com/zhd36/ocr-autoresearch) - OCR research: adapts autoresearch to ICDAR2015 scene-text recognition by editing one `train.py`, running fixed 5-minute CRNN+CTC experiments, and keeping only lower validation character error rates.
- [xgboost-autoresearch](https://github.com/szilard/xgboost-autoresearch) - XGBoost model optimization: provides a reusable template and a concrete end-to-end example that autonomously iterates on feature engineering and XGBoost hyperparameters for tabular datasets, actively searching the web for domain knowledge and ML best practices to inform each experiment, and delivering sustained AUC improvements across successive iterations.
- [Tennis XGBoost Autoresearch](https://github.com/buildoak/tennis-xgboost-autoresearch) - Sports analytics research: applies a Karpathy-style keep/revert loop to a 245K-match tennis XGBoost pipeline, then hardens the evaluator after the agent learned to game mutable ROC-AUC scoring.
- [Bio-Autoresearch](https://github.com/monk1337/Bio-Autoresearch) - Drug discovery research: applies a Karpathy-style autoresearch loop to rare-disease drug repurposing on PrimeKG, running 15 GPU experiments with keep/revert decisions and lifting held-out per-disease AUPRC from 0.284 to 0.761.
- [autoresearch-quantum](https://github.com/saymrwulf/autoresearch-quantum) - Quantum research: runs incumbent/challenger autoresearch ratchets for encoded magic-state experiments, screens candidates on cheap noisy simulations, and promotes only justified challengers to expensive backends while logging transferable lessons.
- [kaggle-autoresearch](https://github.com/aplassard/kaggle-autoresearch) - Tabular ML research: adapts Karpathy-style autoresearch to Kaggle competitions such as Titanic, House Prices, and Store Sales by iterating on feature and model code, logging approved baselines, and accepting only cross-validation improvements over fixed thresholds.
- [MiniMax M2.7: Early Echoes of Self-Evolution](https://www.minimax.io/news/minimax-m27-en) - AI-lab research: describes an internal research agent that automates 30%-50% of RL workflow and a 100+ round keep/revert scaffold-optimization loop that improved internal evaluation scores by 30%.
- [autoresearch-macro](https://github.com/wegard/autoresearch-macro) - Macroeconomic forecasting research: runs LLM-guided outer-loop search over Chronos-2 covariates, transforms, and fine-tuning settings, keeping only validation-era forecast improvements across pseudo-real-time Norway, Canada, and Sweden benchmarks.
- [autoresearch-dqn](https://github.com/raphaelschwinger/autoresearch-dqn) - RL algorithm research: applies the autoresearch loop to a CartPole training script, logging 39 iterations that replaced an unstable DQN baseline with a REINFORCE agent that reaches reward 500 in about 5 seconds instead of about 3 minutes.
- [AutoMedal](https://github.com/Flameingmoy/automedal) - Kaggle competition research: adapts Karpathy's keep/revert loop into strategist, researcher, and experimenter phases, journaling 24 tabular-competition experiments and keeping only lower `val_loss` changes on a fixed leaderboard-oriented harness.
- [autoresearch-qwen](https://github.com/wadeKeith/autoresearch-qwen) - Document VQA research: adapts Karpathy's keep/discard loop to Qwen3-VL on the official DocVQA benchmark by fixing `evaluate.py`, limiting edits to `train.py`, and accepting only higher full-validation ANLS scores.
- [Wine Variety Prediction with LLMs](https://github.com/ivanfioravanti/wine_variety_classification) - ML fine-tuning research: uses a Karpathy-inspired agent loop to edit one LoRA YAML config, parse `HPSEARCH_RESULT` accuracy from short MLX runs, log each trial in JSONL, and revert worse hyperparameter changes on the wine-classification benchmark.
- [Autoresearch for Research](https://github.com/michK/Autoresearch-for-Research) - Physics research: uses an LLM to hypothesize, implement, run, and interpret PDE experiments across five domains (Navier-Stokes, Kuramoto-Sivashinsky, Gray-Scott, NLS, CGLE), achieving 7-24× score improvements with no problem-specific training.
- [ScaleAutoResearch-Ramsey](https://github.com/ypwang61/ScaleAutoResearch-Ramsey) - Mathematics research: scales autoresearch to Ramsey number computation, discovering new lower bounds R(3,17)≥93 and R(4,15)≥160 that improved 32-year-old records after even DeepMind's AlphaEvolve could not.
- [bountyhunter: Vesuvius Autoresearch](https://github.com/jonmarrs/vesuvius-autoresearch) - Scientific research: deploys the first autonomous research swarm for the Vesuvius Challenge, running a full CV research loop with hypothesis generation, hyperparameter optimization, model training, and keep/discard decisions to uncover optimal configurations for reading ancient carbonized scrolls.
- [AutoGo](https://github.com/ericjang/autogo) - Game AI research: applies Karpathy's autoresearch to training a Go-playing AI from scratch, using cheap self-play data and fixed-time eval to keep only network architecture and training improvements across iterations.
- [autoresearch-speedrun](https://github.com/PashaDolgirev/autoresearch-speedrun) - NanoGPT speedrun research: applies Karpathy-style autoresearch with a two-stage paired-seed acceptance funnel and a curated literature-backed idea pool, cutting val_loss from 3.9249 to 3.8093 across 30 experiments with 6 accepted changes out of ~24 honest discards.
- [autoresearch-gym](https://github.com/gabec-slop/autoresearch-gym) - Robotics RL research: provides a Gymnasium workbench for agent-driven RL research loops under fixed benchmark contracts with live dashboard and deterministic evaluation, following the Karpathy autoresearch pattern with candidate training and metric inspection.
- [automat](https://github.com/m-cobelli/automat) - Materials science research: applies Karpathy's autoresearch to design composition-only descriptors for materials regression tasks, requiring the agent to justify scientific reasoning behind each proposed descriptor before evaluating against held-out splits.
- [wattcast-autoresearch](https://github.com/kristenmartino/wattcast-autoresearch) - Energy demand forecasting: applies Karpathy's autoresearch to weather-aware energy demand forecasting across 8 U.S. grid regions, iterating on feature engineering and hyperparameters from a 3.13% MAPE baseline.
- [dreamworld](https://github.com/ehsaaniqbal/dreamworld) - World models research: builds an agent-friendly autonomous research loop for pixel-based world model training on CarRacing-v3, inspired by AutoGo and autoresearch, with remote GPU orchestration via Modal and keep/discard decisions across tokenizer, dynamics, and planning experiment iterations.
- [lawforge](https://github.com/PAMF2/lawforge) - Mathematics theorem proving research: applies a Karpathy Loop outer driver with Agent57 bandit meta-controller and arXiv-scanning autoresearch to Lean 4 equational-theory proving, keeping only edits that improve val_solved_rate across automatically proposed hypothesis arms.
- [AutoResearch-RL](https://github.com/epappas/autoresearch-rl) - RL research: provides a continuous autoresearch framework with frozen prepare.py and mutable train.py separation, supporting grid, random, LLM, and hybrid experiment policies across local and cloud GPU targets.
- [Agentic ML for HAR](https://github.com/DaryLee/agentic-ml) - HAR research: applies Karpathy's autoresearch to Human Activity Recognition on PAMAP2 with a single mutable file, 300-second fixed budgets, file-based versioning, and macro F1 hill-climbing.
- [Coffee Value Autoresearch](https://github.com/jintaili/coffee-value-autoresearch) - ML model research: applies autoresearch to specialty coffee rating and price prediction with an append-only experiment ledger and explicit keep/discard decisions across fixed validation splits.
- [autoresearch-folktales](https://github.com/thu-vu92/autoresearch_folktales) - NLP research: adapts Karpathy's autoresearch to train a small GPT on folktales dataset entirely on Apple Silicon, with a published YouTube walkthrough demonstrating the complete keep/discard loop across the three-file architecture.
- [autoresearch-mol](https://github.com/ewijaya/autoresearch-mol) - Molecular transformer research: applies autoresearch to discover optimal transformer architectures for molecules (SMILES) and proteins by editing model code and keeping only lower validation-loss designs across 3,106 experiments.
- [DrugSAGE](https://arxiv.org/abs/2605.15461) - Drug discovery research: builds a self-evolving agent experience framework that accumulates and reuses knowledge across drug discovery tasks sharing structural similarities through autoresearch-style keep/discard loops.
- [Agentic Design of Compositional Descriptors via Autoresearch](https://arxiv.org/abs/2605.14671) - Materials science research: uses AI agents to autonomously design composition-only descriptors for materials-property prediction, requiring scientific reasoning justification before accepting each proposed descriptor against held-out evaluation splits.
- [SciMLx](https://github.com/moatasim-KT/SciMLx) - Neural operator research: provides an agent-driven autonomous research platform optimized for Apple Silicon (MLX) that discovers neural operators such as Fourier Neural Operators and DeepONet for solving PDEs through autoresearch-style experiment loops.
- [Vision Autoresearch](https://github.com/rycerzes/vision-autoresearch) - Vision research: runs a multi-agent autonomous experiment loop for vision model finetuning on classify, detect, and segment tasks, proposing config changes and auto-promoting wins against the current master on consumer GPUs.
- [Vesuvius AutoResearch](https://github.com/mojomast/vesuvius-autoresearch) - Vesuvius Challenge research: provides an evidence-gated autonomous ML research loop with MetricContract enforcement, promotion gates, provenance tracking, and leave-one-out validation for ink-detection experiments across 1,600+ recorded runs.
- [auto-alphafold3](https://github.com/ashtonchew/auto-alphafold3) - Protein folding research: applies Karpathy-style autoresearch to NanoFold-style AlphaFold3-lite with locked C-alpha lDDT benchmark, falsification gates, and Modal-backed trial infrastructure for monomer protein folding.
- [autoresearch-sft-grpo](https://github.com/priyanlc/autoresearch-sft-grpo) - RL research: applies Karpathy-style autoresearch to the NVIDIA Nemotron Model Reasoning Challenge on Kaggle, using SFT and GRPO training with autonomous keep/discard decisions across 30+ experiments.
- [chess-autoresearcher](https://github.com/rzhang2004/chess-autoresearcher) - Game AI research: runs an autoresearch loop over Sunfish chess engine hyperparameters via 50-game head-to-head matches with a 55% win-rate keep threshold, finding defaults are already near-optimal through 46 controlled experiments.
- [ram_poc](https://github.com/yashraj59/ram_poc) - Biological research: applies Karpathy-style autoresearch to the Arc Institute Virtual Cell Challenge for perturbation prediction using a dual-pathway adaptive memory architecture with autonomous Debate Council mode and a 200-experiment stop cap.
- [repurpose-agent](https://github.com/RitataLU/repurpose-agent) - Drug repurposing research: applies a Karpathy-style autoresearch loop to rank 169 GWAS-orphan genes by drug repurposing potential, iterating on Spearman-rank correlation scores across 10 scoring experiments with keep/discard decisions.
- [GigaWorld-Policy-0.5](https://arxiv.org/abs/2607.13960) - Robotics WAM research: the GigaAI team uses an agent-based AutoResearch pipeline to systematically search training configurations for their action-centered World Action Model, achieving 85ms inference on an RTX 4090 while reducing manual hyperparameter intervention through autonomous configuration discovery.
- [ENPIRE: Agentic Robot Policy Self-Improvement](https://research.nvidia.com/labs/gear/enpire/) - Robotics research: deploys a multi-agent physical autoresearch harness (NVIDIA GEAR/CMU/UC Berkeley) where Codex, Claude Code, and Kimi Code agents autonomously propose robot policy improvements, test them on real hardware with auto-reset and auto-verification, and keep only changes that raise success rate, reaching 99% on dexterous tasks (GPU insertion, zip-tie cutting, pin insertion) while scaling to 8-robot fleets with explicit mean-robot-utilization and mean-token-utilization metrics.
- [Can AI agents conduct open-ended AI research?](https://arxiv.org/abs/2607.27191) - Research evaluation: provides early evidence from two case studies on whether AI agents can conduct open-ended research beyond fixed-benchmark optimization, examining the gap between metric-driven hill-climbing and genuine scientific discovery.
- [Recovering Wasted Compute in Autoresearch Agents](https://github.com/tingtang2/autoresearch-compute-recovery) - Autoresearch efficiency: COLM 2026 paper proposing methods to recover compute wasted during failed or discarded autoresearch experiments, turning previously lost GPU-hours into reusable training progress.
- [Agentic AutoResearch for Space Autonomy](https://arxiv.org/abs/2606.20394) - Aerospace control research: applies an auditable LLM-driven autoresearch agent to spacecraft guidance, navigation, and control problems, iterating on control policies against simulation-based evaluation and keeping only improvements that pass auditability gates.
- [autoresearch-lgb](https://github.com/sorzz444/autoresearch-lgb) - Anti-fraud research: applies Karpathy-style autoresearch to LightGBM feature engineering for a BCA Bank Indonesia anti-fraud victim model, using OpenClaw with an OpenProse loop file and a chmod-444-locked prepare.py that enforces IV→Correlation→Top69 PreScreen→Optuna→OOF as an immutable pipeline so the agent can only edit the FEATURES list and engineer_features() in train.py.
- [autodidact-autoresearch](https://github.com/itsflownium/autodidact-autoresearch) - Small-model autonomous research: extends Karpathy-style autoresearch to a 1M-parameter transformer with PatchRCT (randomized controlled trials on patched model changes) and Bayesian downstream-reward estimation, exploring whether structured experimental design improves sample efficiency at tiny model scales.
- [mist-autoresearch](https://github.com/mist-medical/mist-autoresearch) - Medical imaging research: applies autoresearch to 3D medical image segmentation with MIST, iterating on model configurations against segmentation metrics in a domain where ground-truth annotations are expensive.
- [Arbor](https://github.com/RUC-NLPIR/Arbor) - Generalist autonomous research: an autonomous research agent (RUC-NLPIR, arXiv:2606.11926) that proposes hypotheses, edits code, runs real experiments, and keeps only improvements that survive held-out evaluation, growing a persistent hypothesis tree across branches — beats Claude Code and Codex by 2.5× on the same compute budget across BrowseComp, Terminal-Bench 2.0, and Math-Reasoning, with 86.36% Any-Medal on MLE-Bench Lite.
- [FAROS](https://github.com/OpenNSWM-Lab/FAROS) - AutoResearch operating system: a blueprint-driven AutoResearch runtime (1,566 ⭐) that orchestrates AI research workflows from idea generation and experiments to paper writing and peer review, designed as an extensible foundation for the LLM research domain with a 1.1.0-rc1 release.
- [Recursive automated AI research](https://github.com/recursive-org/first-steps-toward-automated-ai-research) - Automated ML research: builds a system that proposes, implements, validates, and composes improvements across many research threads, beating the autoresearch@home community solution on NanoChat (0.9109 vs 0.9372 val_bpb), the 2-year human-optimized NanoGPT Speedrun record (77.5s vs 79.7s), and the SOL-ExecBench kernel optimization leaderboard (0.754 vs 0.699).
- [diffusers-pipeline-autoresearch](https://github.com/deep-diver/diffusers-pipeline-autoresearch) - Image generation research: applies Karpathy-style autoresearch to Diffusers FLUX.2 pipeline configs on JarvisLabs GPUs, running 10 rounds of candidate sweeps and keeping only prompts, aspect ratios, and semantic anchors that improve a unified visual-judge score for a multi-floor architectural cutaway target.
- [AutoScientists](https://github.com/totaland/autoscientists) - Multi-agent scientific experimentation: deploys a decentralized team of AI agents that self-organize around hypotheses, critique proposals, and share successes across long-running autoresearch-style loops, achieving +8.33% on BioML-Bench and 1.9× faster nanoGPT convergence over single-agent baselines.
- [Writing-Driven Autoresearch](https://github.com/happyhappy-jun/writing-driven-autoresearch) - Scientific research: maintains a submittable paper from the first minute and runs a modify → measure → verify → revise loop in which every experiment must back a specific claim in the draft, rewriting or deleting claims the measurements falsify.
- [Agon](https://github.com/AutoResearch-Factory/Agon) - Scientific research: extends Karpathy's autoresearch with Prompt Economy, organizing scientist/coder/auditor loops across more than ten domains through a modify→verify→keep/discard→repeat cycle, demonstrated in a 30-day unattended run.
- [AutoResearch Survey](https://haizhaoyang.github.io/research/autoresearch-survey.html) - Autoresearch landscape: systematizes 56 autonomous research systems along seven axes, mapping the gap between what systems can produce and what they can defend before release.
- [math-autoresearch](https://github.com/takumayellow/math-autoresearch) - Mathematical research: applies an AI-driven autoresearch pipeline to open graph theory conjectures (Graffiti.pc/TxGraffiti) with a search→finite certificate→independent verification→Japanese LaTeX paper workflow, requiring formal proof certification before any claim is accepted.
- [pla-fea-autoresearch](https://github.com/DJLougen/pla-fea-autoresearch) - Materials engineering: applies an open simulation and physical-validation toolkit with CalculiX FEA to test PLA 3D-printing infill ideas through autoresearch-style iterative hypothesis testing.
- [low-light-geolocalization-autoresearch](https://github.com/akaalias/low-light-geolocalization-autoresearch) - UAV vision research: applies a Claude-driven autoresearch loop to train per-area scene-coordinate models for low-light visual geolocalization, targeting sub-$5 ESP32-P4 hardware deployment.
- [autoMartiniAgent](https://github.com/ljding94/autoMartiniAgent) - Molecular dynamics research: combines an agent skill, MCP server, and autoresearch protocol to automate AA → Martini 3 coarse-grained mapping, applying keep/discard iteration to force-field parameter selection.
- [qwen3-vl-autoresearch](https://github.com/mikhutchinson/qwen3-vl-autoresearch) - Vision-language research: applies leakage-controlled Qwen3-VL LoRA autoresearch on Apple Silicon, with an honest inconclusive confirmation study that explicitly reports when the loop found no reliable improvement despite rigorous experimental design.

### Software / Systems Optimization

Source file: [`categories/software-systems-optimization.md`](categories/software-systems-optimization.md)

- [karpathy/autoresearch](https://github.com/karpathy/autoresearch) - ML training optimization: the original autoresearch loop where an agent edits a GPT training script, runs fixed-time experiments, and keeps only improvements in validation bits-per-byte.
- [AutoKernel](https://github.com/RightNow-AI/autokernel) - GPU optimization: applies Karpathy-style autoresearch to kernel bottlenecks, iterating on code, benchmarking, and keeping only changes that improve speed without breaking correctness.
- [autoresearch-webgpu](https://github.com/lucasgelfond/autoresearch-webgpu) - Browser ML optimization: ports Karpathy's autoresearch into the browser so agents can generate training code, run GPU-backed experiments, and feed losses back into the next iteration.
- [autoresearch-local-llm](https://github.com/SohniSwatantra/autoresearch-local-llm) - Local ML optimization: replaces Claude Code with a local Qwen model to run the standard autoresearch keep/revert loop on a shared single GPU.
- [Shopify Liquid performance work via autoresearch](https://simonwillison.net/2026/Mar/13/liquid/) - Software optimization: Tobi Lütke applied an autoresearch loop to Shopify's Liquid template engine, producing 93 automated commits that improved parse+render performance by 53% with 61% fewer allocations.
- [Autoresearch for SAT Solvers](https://github.com/iliazintchenko/agent-sat) - SAT solver optimization: runs parallel MaxSAT experiments, updates reusable solver code plus expert memory, and improves public benchmark configurations against 2024 competition baselines.
- [autoresearch — Heuristic CP Edition](https://github.com/garipovroma/autoresearch-heuristic) - Heuristic solver optimization: adapts autoresearch to C++ competitive-programming solvers by editing only `solver.cpp`, scoring fixed benchmark instances, and keeping only lower average solution costs.
- [Autoresearch for game development](https://github.com/Centipede5/autogamestudio) - HTML5 Game Development: Runs agents to build better games based on player feedback and usage metrics, benchmarks using game ELO in 1/1 matchups.
- [SiliconSwarm@Ensue](https://www.ensue-network.ai/lab/ane) - Apple Silicon inference optimization: uses a multi-agent autoresearch loop to test ANE graph changes across chips and reports up to 6.31× lower median DistilBERT latency than CoreML.
- [Flash-MoE](https://github.com/gorroai/flash-moe) - Apple Silicon inference optimization: uses a Claude Code autoresearch loop to run 43 Metal optimization experiments on Qwen3.5-397B and reach 20.34 tok/s on an M5 Max by overlapping SSD reads with GPU compute.
- [Research-Driven Agents: When an agent reads before it codes](https://blog.skypilot.co/research-driven-agents/) - LLM inference optimization: extends Karpathy's autoresearch with a literature-review phase that reads papers and competing forks before parallel llama.cpp experiments, landing five kernel fusions and about 15% faster x86 flash-attention generation in about 3 hours.
- [Rails controller tuning with Claude Code /loop autoresearch](https://zenn.dev/dely_jp/articles/3117e590465e38) - Backend performance optimization: adapts Karpathy's keep/discard loop to Rails controller latency by locking benchmark scripts and test data, running 10-minute cycles, and auto-reverting regressions.
- [Pytest speedups via autoresearch feedback loops](https://blog.serverworks.co.jp/2026/03/30/153209) - Test performance optimization: applies autoresearch to a backend pytest suite with a fixed evaluation harness, seven autonomous experiments, and a 295s → 71s keep/discard improvement path.
- [autoresearch-sudoku](https://github.com/Rkcr7/autoresearch-sudoku) - Solver optimization: uses an enhanced autoresearch loop to rewrite a Rust sudoku solver over 312 experiments and beat Tdoku plus rust_sudoku on 4 of 6 standard benchmark datasets.
- [autospec](https://github.com/jeongph/autospec) - Backend service generation: applies an autoresearch-inspired keep-or-revert loop to natural-language business rules, iteratively building a Spring Boot service until Gradle and JUnit evaluation pass without regression.
- [How I used autoresearch to fix Gumroad's flaky tests in a week](https://gumroad.com/blog/p/how-i-used-autoresearch-to-fix-gumroad-s-flaky-tests-in-a-week) - Test reliability: uses OpenClaw autoresearch to run 206 commits and 94 CI cycles that fixed 13 flaky tests while surfacing a real file-ID remapping bug.
- [WinMoE](https://github.com/idan82labs/WinMoE) - Windows inference optimization: uses an AI-driven autoresearch methodology with one-change measurements and keep-or-reject ledgers to lift Qwen3.5-397B throughput from 0.44 to 1.9 tok/s on consumer hardware.
- [ZK Autoresearch — Plonky3 DFT Optimizer](https://github.com/Barnadrot/zk-autoresearch) - ZK prover optimization: applies Karpathy's autoresearch pattern to Plonky3's DFT code, running Rust tests plus Criterion benchmarks and keeping only commits that reduce `coset_lde_batch` time on BabyBear field workloads.
- [autoresearch-go-ane](https://github.com/tmc/autoresearch-go-ane) - Apple Silicon training optimization: ports Karpathy's loop to a Go plus ANE LLM trainer, benchmarking fixed 5-minute TinyStories runs with `benchstat` and keeping only lower `val_loss` configurations.
- [openroad-autoresearch-ibex](https://github.com/maxjohannn/openroad-autoresearch-ibex) - Chip design optimization: applies a fixed-harness autoresearch loop to OpenROAD RTL-to-GDSII experiments on the IBEX CPU, using scout-promote screening and objective-aware history to keep only timing, area, or power improvements.
- [OpenCLI](https://github.com/jackwener/opencli) - Browser automation reliability: adds a Karpathy-style autoresearch harness to OpenCLI, cycling review → modify → commit → verify → decide against fixed V2EX, Zhihu, browser, and save-as-CLI eval suites to keep only reliability improvements.
- [autoresearch-cublas-sam3](https://github.com/rexlee2/autoresearch-cublas-sam3) - GPU kernel optimization: applies an autoresearch loop to SAM3 GEMM tuning by mutating one config at a time, benchmarking on real GPUs, and keeping only changes that improved throughput by 2.14% over 120 experiments on an RTX 3090.
- [autoresearch-mamba](https://github.com/continualm/autoresearch-mamba) - Mamba training optimization: adapts Karpathy's fixed-evaluator, 5-minute keep/discard loop to MLX Mamba-2, Mamba-3, and hybrid Mamba-Transformer models on Apple Silicon by mutating one training surface to lower `val_bpb`.
- [liltrAIner](https://github.com/Snail3D/liltrAIner) - Local LLM fine-tuning optimization: applies a Karpathy-style autoresearch loop to MLX LoRA runs on Apple Silicon, letting an agent mutate training data or config, score eval prompts, and keep or revert each fine-tuning experiment.
- [english-app](https://github.com/shitada/english-app) - Education app optimization: applies an autoresearch-inspired proposer → implement → test → evaluate → keep/discard loop to an English learning app, using pytest, TypeScript checks, and smoke tests to keep only changes scoring at least 6.0 across 10 autonomous iterations.
- [How we built the best browser agent with Auto-Research](https://browser-use.com/posts/online-mind2web-benchmark) - Browser automation optimization: uses parallel Claude Code auto-research loops against Online-Mind2Web, running 20-cycle harness edits with train/validation splits and reaching 97% on the benchmark while rejecting task-specific overfits.
- [Speed up code with pi-autoresearch](https://quanttype.net/p/speed-up-code-with-pi-autoresearch/) - Software performance optimization: applies pi-autoresearch to jsonista's JSON decoding benchmark, keeping only measured wins and lifting one selected benchmark's throughput by 56% while surfacing overfitting risks in accepted diffs.
- [588x Faster SQLite Ingestion With an Autoresearch Loop](https://www.luiscolunga.com/posts/autoresearch-etl-optimization/) - ETL performance optimization: applies pi-autoresearch to a Python financial-data ingestion pipeline, benchmarking 50,000-row SQLite writes and keeping fixes that cut processing time from about 397s to 0.675s.
- [auto-data-pipeline-optimization](https://github.com/Henry-Xiao-HX/auto-data-pipeline-optimization) - Data pipeline optimization: adapts Karpathy's three-file keep/revert loop to data engineering, letting an agent mutate compression, partitioning, chunking, and query logic against a fixed efficiency score and achieving +11.3% improvement over 20 experiments.
- [nnmetal + labrat](https://github.com/duanebester/nnzap) - Apple Silicon inference optimization: uses an autonomous Zig and Metal autoresearch loop that snapshots engine files, makes one kernel change at a time, runs compile, test, and benchmark gates, and commits only throughput or latency wins above a fixed threshold.
- [HashSmith, Part 3: I Automated My Way to a 27% Faster Hash Table](https://bluuewhale.github.io/posts/i-automated-my-way-to-a-27-percent-faster-hash-table/) - Data-structure performance optimization: uses a Claude Code auto-optimize loop to profile, benchmark, and keep only wins on a JVM SwissTable implementation, landing three accepted changes and 13%-32% gains across eight benchmark scenarios.
- [claude-code-bench](https://github.com/sawzhang/claude-code-bench) - AI coding workflow optimization: applies Karpathy-style autoresearch to Claude Code's 7-dimensional configuration space, running benchmark tasks and keeping only profiles that improve quality-adjusted scores for research depth, correctness, and convention adherence.
- [autooptimization](https://github.com/damahua/autooptimization) - Systems optimization: applies a profile-first autoresearch protocol to codebases like ClickHouse, Chroma, DataFusion, and RocksDB, keeping only statistically benchmarked optimizations backed by stack-level profiling evidence.
- [helix-inference-opt](https://github.com/VectorInstitute/helix-inference-opt) - LLM inference optimization: applies a fixed 1-minute autoresearch benchmark to Qwen2.5-0.5B decoding on WikiText-2, rewriting only `infer.py` and keeping throughput gains only when bits-per-byte quality stays within a 1% guard.
- [autoresearch-inference-optimization](https://github.com/lawjarp-simplismart/autoresearch-inference-optimization) - Inference serving optimization: lets an agent rewrite `serve.sh` plus `experiment.yaml`, benchmark OpenAI-compatible servers under throughput, latency, and memory constraints, and keep only higher-scoring serving configs in `experiments.jsonl`.
- [PolyTrader](https://github.com/dougsls/polytrader) - Trading-system performance optimization: applies autoresearch to PolyTrader's signal-detection hot path, keeping only test-clean code changes that cut end-to-end tracker latency from 25.7 ms to 0.46 ms across a published 10-iteration benchmark run.
- [autoresearch-lora-buzhou](https://github.com/bzjiang401/autoresearch-lora-buzhou) - Local LoRA fine-tuning optimization: adapts autoresearch to user-chosen LoRA training goals by establishing a confirmed baseline, changing one parameter at a time, rerunning >1% wins for confirmation, and promoting only verified `val_loss` improvements to the best checkpoint.
- [ZeroAPI](https://github.com/dorukardahan/ZeroAPI) - Model-routing optimization: applies an autoresearch loop to OpenClaw routing policy constants by rerunning evals on routing logs, changing one setting at a time, and keeping only traffic-verified improvements.
- [One Hour, 37% Faster: Applying Autoresearch to Our Search Ranking Inference Endpoint](https://medium.com/idealo-tech-blog/one-hour-37-faster-applying-autoresearch-to-our-search-ranking-inference-endpoint-34cffc08e373) - Search ranking optimization: applies Karpathy's edit → measure → keep/revert loop to idealo's production LTR inference endpoint, reducing preprocessing latency 5.9× and end-to-end latency 37% in one hour for ~$7.
- [arete autoresearch-compiler](https://github.com/upvalue/arete/blob/main/autoresearch-compiler.md) - Compiler optimization: applies a Karpathy-style keep/revert loop to a self-hosting Scheme compiler, benchmarking fixed workloads and keeping only changes that improve runtime performance.
- [auto-arch-tournament](https://github.com/FeSens/auto-arch-tournament) - CPU architecture optimization: extends Karpathy's autoresearch loop to SystemVerilog RTL, proposing, implementing, and measuring microarchitectural hypotheses through riscv-formal, Verilator cosim, and FPGA place-and-route to achieve +91.9% CoreMark on a RISC-V core.
- [autoresearch-function](https://github.com/vneyman/autoresearch-function) - Function optimization: adapts Karpathy's autoresearch to a CPU-only scaffold that benchmarks arbitrary functions against correctness, execution time, memory, and throughput metrics, keeping only edits that improve a composite score.
- [vllm-autoresearch](https://github.com/pitcany/vllm-autoresearch) - Inference serving optimization: applies Karpathy's autoresearch to find optimal vLLM serving configurations for Llama 3.3 70B on 2× RTX 5090, editing one config at a time and benchmarking against throughput, latency, and noise-floor metrics with keep/discard decisions.
- [WAFPlanet Autoresearch](https://github.com/wafplanet/autoresearch) - WAF security optimization: applies Karpathy's autoresearch to OWASP ModSecurity CRS configuration, running 30 autonomous experiments and lifting balanced accuracy from 80.8% to 98.4% while cutting false positives by 94.5%.
- [lance-autoresearch](https://github.com/ModernRelay/lance-autoresearch) - Database kernel optimization: adapts Karpathy's one-file keep/revert loop to Lance hot-path Rust kernels with bit-equivalent correctness oracle and a landed −43% geomean PQ L2 distance speedup on Apple Silicon.
- [Türkçe Hoca — AI Turkish Tutor](https://github.com/Techris93/turkish-tutor) - Education app optimization: applies an autoresearch swarm loop to a Turkish language tutor, continuously improving CEFR-adaptive teaching strategies through autonomous evaluation and iteration.
- [Autoresearching BM25 on MSMarco](https://softwaredoug.com/blog/2026/05/17/autoresearching-a-better-msmarco-bm25.html) - Search ranking optimization: applies Karpathy-style autoresearch to iteratively improve a BM25 search ranker on the MSMarco passage retrieval dataset by editing ranking code and keeping only NDCG improvements.
- [Google Play Description Autoresearcher](https://github.com/kevserimirogullari-hash/google-play-description-autoresearcher) - ASO optimization: applies Karpathy-style autoresearch to Google Play long-description optimization by scoring keyword density, coverage, and structure across targeted experiments with keep/discard decisions.
- [VRPTW Auto-Research](https://github.com/dguimarans/vrptw_autoresearch) - Logistics optimization: applies Karpathy-style keep/revert loop to Vehicle Routing Problem with Time Windows using DeepSeek-R1 and Qwen2.5-Coder agents that propose, implement, and benchmark single algorithmic changes to a Rust solver against fixed 400-customer instances.
- [msmarco-bm25-autoresearch](https://github.com/vespaai-playground/msmarco-bm25-autoresearch) - Search ranking optimization: reproduces MSMARCO BM25 rank-feature optimization on Vespa with three approaches including an autonomous LLM loop using paired-rotation validation across 10 train splits.
- [tsfm-autoresearch](https://github.com/zd87pl/tsfm-autoresearch) - Resource forecasting: validates per-request autoresearch over frozen TimesFM for multi-tenant resource forecasting, staying within a 200ms inference latency budget across 10 completed milestones.
- [How autoresearch found a 3-year-old bug in ClickHouse](https://posthog.com/blog/autoresearch-query-bug) - Database query optimization: used pi-autoresearch with lane-structured hypothesis exploration at a team offsite to discover a timestamp-wrapping bug that had hidden for 3 years, cutting ClickHouse granule scans by 62%.

### Evaluation / Red Teaming

Source file: [`categories/evaluation-red-teaming.md`](categories/evaluation-red-teaming.md)

- [Claudini](https://github.com/romovpa/claudini) - AI safety research: uses an autoresearch-style loop to invent and benchmark new LLM attack algorithms, keeping only methods that outperform baselines.
- [autovoiceevals](https://github.com/ArchishmanSengupta/autovoiceevals) - Voice AI evaluation: attacks voice agents with adversarial callers, proposes prompt changes one at a time, and keeps or reverts them based on eval results.
- [We Used Autoresearch on Our AI Skill, It Taught Us to Write Better Tests](https://langfuse.com/blog/2026-03-24-optimizing-ai-skill-with-autoresearch) - AI skill evaluation: runs a prompt-migration skill against six fixed codebase test cases, scores each change on correctness, completeness, and efficiency, and keeps only improvements while cherry-picking around harness overfit.
- [AutoPrompter](https://github.com/gauravvij/AutoPrompter) - Prompt evaluation: combines promptfoo-style metrics with autoresearch-style closed-loop iteration, generating datasets, testing target models, and refining prompts through a persistent experiment ledger.
- [AutonomousTester](https://github.com/executeautomation/autoresearch_playwright) - UI testing evaluation: adapts autoresearch to Playwright test generation by editing only `tests/test_suite.py`, measuring `coverage_score`, and auto-fixing or discarding test changes until coverage improves.
- [Autoresearch for Agents from Scratch](https://github.com/rungalileo/autoresearch-for-agents) - Support-agent prompt evaluation: applies Karpathy's keep/revert loop to `system_prompt.md`, scoring frozen adversarial support cases by tool-call accuracy and lifting the prompt from 0.05 to 0.80 over 15 experiments.
- [LLM Privacy + Cost Router — Classifier Experiment](https://github.com/clawdbotags/llm-privacy-classifier) - Privacy classification evaluation: runs a Karpathy-style autoresearch experiment across regex and prompt variants for a hybrid LLM privacy classifier, validating the best configuration at 96.7% holdout accuracy with 4.6% false negatives.
- [AutoMemory](https://github.com/Shelter41/automemory) - Agent memory evaluation: lets an agent rewrite its own memory system against LongMemEval, using an immutable evaluator over random question samples and iterating on code plus strategy notes in response to scored failures.
- [How to stop your autoresearch loop from cheating](https://www.cerebras.ai/blog/how-to-stop-your-autoresearch-loop-from-cheating) - Autoresearch evaluation hardening: reports 71 experiments across nanochat training and MoE compression, showing loops drift quickly unless experiments are isolated and evaluator gates block shortcut gains.
- [Autoreason](https://github.com/NousResearch/autoreason) - Output evaluation: extends Karpathy-style autoresearch to subjective writing and coding tasks by running incumbent-versus-revision-versus-synthesis tournaments under blind multi-judge Borda scoring and stopping only when the unchanged version wins twice, outperforming standard self-refinement baselines on writing tasks and 150 CodeContests problems.
- [AutoResearchBench](https://github.com/CherYou/AutoResearchBench) - Evaluation benchmark: a dedicated benchmark for autonomous scientific literature discovery with complementary deep and wide research tasks, showing that even the most powerful LLMs achieve only ~9% accuracy on literature-focused open-ended search.
- [Jailbreak Autoresearch](https://github.com/davidondrej/jailbreak-autoresearch) - Jailbreak red-teaming: applies Karpathy's autoresearch loop to prompt-harness experiments, testing different header and footer harnesses against a fixed body and scoring responses against a rubric to find more effective jailbreak strategies.
- [JustAsk](https://github.com/x-zheng16/JustAsk) - System prompt extraction: uses autoresearch-style curiosity-driven code agents to iteratively probe and reveal system prompts from frontier LLMs, accepted at ICML 2026.
- [DSBench AutoResearch](https://github.com/dlmastery/autoresearch_dsbench) - Benchmark evaluation: applies Karpathy-style hill-climbing to each of DSBench's 74 Kaggle modeling and 38 Modeloff analysis tasks, running per-task autoresearch repos with a forensic audit that beats 82/112 DSBench baselines.
- [Trace2Evolve](https://github.com/mohammed840/trace2evolve-autoresearch) - Customer-support agent evaluation: applies Karpathy-style autoresearch to improve a tool-using support agent by generating hard cases, scoring traces, classifying failures, and keeping candidate improvements only when benchmark metrics and reliability gates pass across retail and airline task splits.
- [SciTriage](https://github.com/shelter951/SciTriage) - Autoresearch evaluation: evidence gates and claim discipline for AutoResearch agents, providing a diagnostic layer that determines whether experiment results are meaningful before deciding to continue or stop a run.
- [claude-haiku-harness](https://github.com/jafanlim/claude-haiku-harness) - Prompt evaluation harness: uses an AutoResearch-style eval-driven loop to iteratively benchmark and improve prompts against production-quality targets, aiming to match Claude Haiku 4.5 quality with Sonnet/Opus benchmarks.
- [AutoMedBench](https://github.com/AutoMedBench/AutoMedBench) - Medical evaluation benchmark: provides a medical-domain benchmark (MedAutoBench) for evaluating autoresearch agents on MedQA, MedMCQA, and PubMedQA clinical tasks with sandboxed execution and automated scoring.
- [NanoGPT-Bench](https://github.com/IntologyAI/NanoGPT-Bench) - ML research benchmark: evaluates AI systems on open-ended GPT-2 speedrun research tasks, finding current coding agents recover under 10% of human-achievable speedup and primarily tune hyperparameters rather than perform algorithmic innovation.
- [ResearchArena](https://arxiv.org/abs/2605.19156) - Research loop evaluation: provides a scaffold for off-the-shelf agents to carry out full research loops from ideation through experimentation to paper writing, finding that feasibility does not yet equal quality in autonomous research.
- [Anti-Autoresearch](https://github.com/wanshuiyin/Anti-Autoresearch) - Autoresearch integrity forensics: derived from the ARIS research-agent platform, applies a three-layer audit stack (experiment-audit, result-to-claim, paper-claim+citation-audit) with cross-model adversarial review and deterministic verdict, detecting 39 hack-patterns across 7 families to flag manipulated or fabricated autoresearch results.
- [AHA: Agent Hacks Agent](https://github.com/henrymao2004/Auto-research-red-teaming) - Production-agent red-teaming: applies an autoresearch loop to red-team trajectories, surfacing reusable failure mechanisms and building a frozen Vulnerability Concept Graph so agents discover their own attack surfaces before adversaries do, with published paper, casebook, and interactive website.
- [Autoresearch Novelty Bench](https://github.com/evo-hq/autoresearch-novelty-bench) - Novelty benchmark: evaluates autonomous research agents on whether their proposed hypotheses are novel, anticipate future breakthroughs, or merely rediscover known techniques, built on Prime Intellect's speedrunning archive.
- [ResearchClawBench](https://github.com/InternScience/ResearchClawBench) - Scientific research evaluation: benchmarks 40 real-science tasks across 10 disciplines, scoring AI agents on whether they can re-discover or surpass published research findings through autonomous pipelines.

### Finance / Trading

Source file: [`categories/finance-trading.md`](categories/finance-trading.md)

- [atlas-gic](https://github.com/chrisworsey55/atlas-gic) - Trading: applies Karpathy-style autoresearch to a swarm of market agents, rewriting the worst-performing prompts and keeping changes only when rolling Sharpe improves.
- [autoresearch-trading](https://github.com/erix/autoresearch-trading) - Options trading: applies an autoresearch-style keep/revert loop to SPY strategy parameters, logging each experiment against backtest metrics.
- [autoresearch-trading](https://github.com/dietmarwo/autoresearch-trading) - Trading research: combines Karpathy-style autoresearch with classical optimization so the agent iterates on strategy structure while an optimizer tunes parameters and walk-forward validation decides what survives.
- [binance-trading-karpathy-autoresearch-results](https://github.com/dxeroz2/binance-trading-karpathy-autoresearch-results) - Crypto trading research: publishes results from 4 years of Binance trading data optimized through Karpathy's autoresearch method, with an iterative strategy proposal → backtest → keep/discard loop across multiple assets.
- [BTCautoresearch](https://github.com/CBaquero/BTCautoresearch) - Bitcoin forecasting: uses Karpathy-style autoresearch to mutate a single formula file, score walk-forward out-of-sample RMSE, and keep only forecasting rules that beat the baseline power law.
- [autoresearch-skfolio](https://github.com/CarloNicolini/autoresearch-skfolio) - Portfolio optimization: edits a single portfolio-research script, runs fixed out-of-sample validation across multiple datasets and reversed-return variants, and keeps only Deflated Sharpe Ratio gains.
- [AutoHypothesis](https://github.com/arteemg/AutoHypothesis) - Portfolio research: runs a Karpathy-style autoresearch loop on `agent.py`, iterating on DEV data and keeping only stock-selection hypotheses that clear one-shot holdback and walk-forward gates before final holdout evaluation.
- [autoresearch-glm](https://github.com/statcafehk/autoresearch-glm) - Credit scoring: adapts autoresearch to Taiwan credit-default prediction by editing feature-policy code and keeping only validation AUC gains in a fixed logistic-GLM benchmark.
- [Feature Research at Machine Speed](https://www.slopepay.com/blog/feature-auto-research) - Credit underwriting: adapts Karpathy's autoresearch to `compute_features.py`, scoring each iteration by Information Value and ending the round after 25 runs once no new strong features emerged, yielding 58 strong features and a +0.023 AUC lift at a matched 20-feature budget.
- [autoresearch-markets](https://github.com/JohnJBoren/autoresearch-markets) - Prediction-market trading research: adapts Karpathy's single-file keep/revert loop to Kalshi data, editing `train.py` and optimizing `val_logloss` on held-out resolved markets.
- [Simmer Autoresearch](https://docs.simmer.markets/plugins/autoresearch) - Prediction-market trading: lets agents mutate skill configs, measure P&L or edge over live trading cycles or historical replays, and auto-commit only the configurations that improve results.
- [Autonomous Trading Strategy Research](https://github.com/Junghwan-Oh/autoresearch-trading) - Crypto trading research: adapts Karpathy's single-file autoresearch loop to Hyperliquid perpetual futures, backtesting each `strategy.py` change on fixed historical data and keeping only score improvements across 103 autonomous experiments.
- [PolyEdge AutoResearch](https://github.com/muze-ai-consulting/polyedge-autoresearch) - Prediction-market arbitrage: applies a Karpathy-style keep/discard loop to Polymarket Up/Down paper trading, mutating one strategy parameter at a time and scoring each multi-window run on P&L, fill rate, and trading frequency.
- [AutoResearch — Autonomous DEX Strategy Discovery](https://github.com/darks0l/autoresearch) - DEX trading research: applies Karpathy-style autoresearch to Base DEX strategies, backtesting one mutation at a time against real Uniswap V3 and Aerodrome data and lifting composite score from 0.421 to 8.176 over 230+ experiments.
- [Winning the Paradigm Prediction Market Challenge with Claude Code](https://github.com/ryanli-me/paradigm-pm-challenge) - Prediction-market market making: uses parallel Claude Code agents as an autoresearch swarm to generate 1,039 strategy variants, run 2,000+ evaluations, and optimize mean edge to a first-place finish in Paradigm's challenge.
- [Autoresearch Trading Strategy Optimizer](https://github.com/VictorFouquet/AutoresearchTrading) - Crypto trading research: applies Karpathy's autoresearch to one editable `strategy.py`, hill-climbing on deterministic historical backtests and keeping only commits that improve `final_portfolio_value / max_drawdown`.
- [Investing Autoresearch](https://github.com/Dvrki/investing-autoresearch) - Trading strategy research: uses an autonomous Claude loop to rewrite `strategy.py`, backtest on held-out market data, and keep only strategies that improve out-of-sample Sharpe under walk-forward, slippage, and fee validation.
- [EMA Crossover Autoresearch](https://github.com/marketcalls/emacrossover-autoresearch) - Equity trading research: adapts Karpathy's three-file autoresearch loop to an SBIN EMA strategy, mutating only `strategy.py`, backtesting a fixed 10-year Indian equities dataset, and keeping only changes that improve a composite return, Sharpe, and drawdown score.
- [NSE AutoResearch](https://github.com/sagar-n/autoresearch-nse) - Equity trading research: adapts Karpathy's single-file keep/revert loop to Indian stock backtesting by mutating only `strategy.py` and keeping only lower composite-score strategies over a fixed 10-year NSE harness.
- [delu-agent](https://github.com/deluagent/delu-agent) - Live crypto trading: runs a self-improving treasury agent on Base with 5 parallel autoresearch loops that evolve the scoring model through 9,000+ backtested experiments 24/7 and execute trades via Bankr without human intervention.
- [investment-autoresearch](https://github.com/lucemia/investment-autoresearch) - Trading strategy research: a Claude Code plugin that runs parallel agents testing single-hypothesis strategy variants in isolated git worktrees, scoring each against baseline buy-and-hold, and resetting from verified insights when incremental search plateaus.
- [autoresearch-crypto](https://github.com/chencore/autoresearch-crypto) - Crypto trading research: applies Karpathy's single-file, backtest-driven keep/revert loop to crypto strategy development with fixed historical data and metric-based acceptance gates.
- [feat(autoresearch): autonomous experiment engine in Juspay Neurolink](https://github.com/juspay/neurolink/pull/922) - Financial infrastructure research: merges an 8,700-line autonomous experiment engine with Karpathy-style sub-agents and git-backed keep/revert decisions into the Juspay Neurolink product codebase.
- [ml-vs-leadlag-jp-stock](https://github.com/kiwiiosaru-jp/ml-vs-leadlag-jp-stock) - Japanese equity trading: applies Karpathy's autoresearch framework to Japanese stock prediction, comparing ML-driven Sharpe maximization against a classical lead-lag PCA strategy on reproducible benchmarks with published write-up.
- [autoresearch-backtesting](https://github.com/topoftheblock/autoresearch-backtesting) - Equity trading: uses an autonomous LLM agent to iteratively rewrite its PyTorch network for SPY directional prediction, backtesting each mutation and keeping only Sharpe improvements in a train → backtest → keep/discard loop.
- [IPL Odds Multi-Agent Autoresearch](https://github.com/dashthird-0/ipl-odds-multiagent-autoresearch) - Sports betting research: deploys 7 Claude Code subagents to forecast IPL match outcomes, grades each forecast by Brier score, and autonomously mutates reasoning rules across a full season without human intervention.
- [Clio](https://github.com/zhongdaweiai/clio) - Prediction-market forecasting: implements autoresearch as a multi-agent, Pareto-scored, time-evolving backtest harness for prediction markets with adversarial validation and bankroll-as-ground-truth.
- [numerai-mcp-autoresearch](https://github.com/rnop/numerai-mcp-autoresearch) - Quantitative finance: applies an agentic autoresearch harness to the Numerai classic tournament with XGBoost, Bayesian optimization, time-series cross-validation, and a custom MCP server for autonomous weekly retraining and submission.
- [trading-autoresearch](https://github.com/vzeman/trading-autoresearch) - Intraday trading research: applies Karpathy-style autoresearch to a PatchTST transformer and Kelly-sized policy, iterating overnight and gating changes by Sharpe lower-CI and drawdown floor with detailed per-iteration reports.
- [quanti-autoresearch](https://github.com/GHCharlesLau/quanti-autoresearch) - Economic research: applies Karpathy-style autoresearch to econometric specification search for GDP per capita growth prediction, iterating on feature selection, estimators, and functional forms against held-out RMSE with structured 4-phase exploration.
- [AutoResearch-based-Trading-Strategy-Generation-and-Testing](https://github.com/nhocconan/AutoResearch-based-Trading-Strategy-Generation-and-Testing) - Crypto trading research: applies Karpathy-style autoresearch to crypto futures strategy discovery with honest simulation guarantees, an LLM agent writing strategies from a knowledge base of quant techniques, and autonomous keep/discard decisions.
- [Auto-Quant](https://github.com/TraderAlice/Auto-Quant) - Crypto trading research: applies Karpathy's autoresearch pattern to FreqTrade strategies on a 5-pair crypto universe, running backtest-driven keep/discard loops that evolved multi-strategy lineups across five versioned runs.
- [noahroboros](https://github.com/upupnoah/noahroboros) - Crypto trading research: applies Karpathy-style autoresearch in Rust to BTC/ETH/SOL strategy optimization over 88 backtest experiments, discovering a simplified RSI(32) momentum strategy with a 2.569 composite score.

### Personal Knowledge / Humanities

Source file: [`categories/personal-knowledge-humanities.md`](categories/personal-knowledge-humanities.md)

- [autoresearch-genealogy](https://github.com/mattprusak/autoresearch-genealogy) - Genealogy: uses Claude Code `/autoresearch` prompts to expand family trees, verify claims against multiple sources, and keep a structured evidence-backed research vault.
- [claude-obsidian](https://github.com/AgriciDaniel/claude-obsidian) - Personal knowledge: uses a Karpathy-style `/autoresearch` skill to run multi-round web research with gap-filling and file source-backed concept, entity, and synthesis pages into a compounding Obsidian wiki vault.

### Knowledge Base / RAG Preparation

Source file: [`categories/knowledge-base-rag-preparation.md`](categories/knowledge-base-rag-preparation.md)

- [AutoRAGsearch](https://github.com/Smasko7/AutoRAGsearch) - RAG retrieval optimization: applies an autoresearch-style loop to a fixed QA benchmark by editing only `rag_pipeline.py`, running local retrieval experiments, and improving retrieval_score from 0.9472 to 0.9867 over 20 autonomous experiments.
- [AutoRAG Research Lab](https://github.com/fran-gen/autoresearch-rag) - RAG pipeline optimization: runs autonomous agents that plan, implement, benchmark, and keep/discard retrieval pipeline changes using Karpathy-mode over EnterpriseRAG-Bench with Docker-sandboxed evaluation and semantic no-op detection.

### Workflow Automation

Source file: [`categories/workflow-automation.md`](categories/workflow-automation.md)

- [PM document optimizer](https://github.com/lifang-mban/pm-document-optimizer) - Product workflow automation: applies a Karpathy-style git ratchet to markdown artifacts like PRDs and strategy docs, scoring each draft with programmatic checks and committing only higher-scoring revisions.
- [Trip Optimizer Pro](https://github.com/michaelpersonal/trip-optimizer) - Travel planning workflow automation: applies the autoresearch pattern to itinerary generation by researching destinations, scoring multi-day plans, and keeping only itinerary mutations that improve a weighted travel-quality score.
- [Autoresearch for Software Development](https://github.com/smallnest/autoresearch) - Software delivery automation: adapts autoresearch to GitHub Issues by rotating agents through implement → review → fix loops, then auto-merging only issues that clear a score gate plus build, lint, and test checks.
- [autobrowse](https://skills.sh/browserbase/skills/autobrowse) - Browser workflow automation: applies an autoresearch loop to browser tasks by iterating on `strategy.md`, replaying tasks with Browserbase, and graduating only reliable workflows into reusable Claude Code skills.

### Infra / Skills / Forks

Source file: [`categories/infra-skills-forks.md`](categories/infra-skills-forks.md)

- [n-autoresearch](https://github.com/iii-hq/n-autoresearch) - Autoresearch infra: extends Karpathy's loop with structured experiment state, multi-GPU parallelism, adaptive search, and crash recovery.
- [autoresearch-evaluation-harness](https://github.com/sou350121/autoresearch-evaluation-harness) - Evaluation infrastructure: compares autoresearch-style proposal strategies under fixed task adapters, explicit scalar scoring, and hard keep/discard gates.
- [autoresearch-mlx](https://github.com/trevin-creator/autoresearch-mlx) - Apple Silicon fork: ports Karpathy's autoresearch to MLX while keeping the fixed-time training budget, single mutable file, and git keep/revert loop.
- [Claude Autoresearch](https://github.com/uditgoenka/autoresearch) - Claude Code skill: generalizes Karpathy's autoresearch into a reusable modify → verify → keep/discard loop for measurable goals beyond ML.
- [claude-autoresearch](https://github.com/Maleick/claude-autoresearch) - Claude Code plugin: runs autoresearch on isolated branches with deterministic verification commands, scheduled overnight sessions, and structured keep/discard reports.
- [lazy-developer](https://github.com/james-s-tayler/lazy-developer) - Claude Code plugin suite: runs repeated autoresearch phases across coverage, build speed, test speed, complexity, and performance goals while enforcing per-phase file locks and revert-on-regression behavior.
- [codex-autoresearch](https://github.com/leo-lilinxiao/codex-autoresearch) - Codex skill: brings the autoresearch pattern to Codex for unattended metric-driven software iteration with automatic keep/discard decisions.
- [gemini-autoresearch](https://github.com/supratikpm/gemini-autoresearch) - Gemini CLI and Antigravity skill: runs goal-driven overnight improvement loops with verify and guard gates, keeping metric wins and automatically reverting regressions.
- [autoresearch-plugin](https://github.com/AILAB-H/autoresearch-plugin) - Claude Code plugin: packages the Karpathy-style experiment loop into init/test/run commands for projects with explicit evaluation scripts and git rollback.
- [Artificial General Research](https://github.com/JoaquinMulet/Artificial-General-Research) - Optimization framework: turns measurable code optimization tasks into autoresearch loops with variance-aware acceptance, artifact detection, and exhausted-approach tracking.
- [autoresearch-engram](https://github.com/tonitangpotato/autoresearch-engram) - Memory extension: adds persistent recall, pattern extraction, and reflection steps to Karpathy's autoresearch so the agent remembers what worked across long runs.
- [pi-autoresearch](https://github.com/davebcn87/pi-autoresearch) - pi extension: generalizes Karpathy's autoresearch into experiment tools, a live dashboard, and slash-command skills for metric-driven optimization beyond ML.
- [openclaw-autoresearch](https://github.com/gianfrancopiana/openclaw-autoresearch) - OpenClaw plugin: ports pi-autoresearch to OpenClaw with pending-run enforcement, confidence scoring, checkpoint files, and git-backed keep/discard semantics.
- [AutoResearch OpenClaw](https://github.com/rmarji/autoresearch-openclaw) - OpenClaw package: runs Karpathy-style keep/revert loops on one text asset by measuring a scalar metric, committing winners, reverting losers, and logging each session to `results.tsv`.
- [autoresearch-opencode](https://github.com/dabiggm0e/autoresearch-opencode) - OpenCode skill: ports pi-autoresearch into OpenCode as a pure skill that logs JSONL experiment runs and resumes autonomous keep/discard loops with built-in tools.
- [pi-autoresearch-studio](https://github.com/jhochenbaum/pi-autoresearch-studio) - pi control plane: adds TUI and web dashboards, plan and ideas editing, and selective PR creation on top of pi-autoresearch sessions.
- [autoresearch-gen](https://github.com/liviaellen/autoresearch-gen) - Scaffold generator: interviews the user, generates a verified autoresearch experiment scaffold, auto-runs the baseline, and repairs broken generated code before handoff to the agent.
- [autoresearch-autoresearch](https://github.com/cavit99/autoresearch-autoresearch) - Meta-autoresearch repo: maintains a portable canonical loop distilled from karpathy/autoresearch and adjacent systems so new evidence can update a reusable agent-verifier architecture across domains.
- [Bilevel Autoresearch](https://github.com/EdwardOptimization/Bilevel-Autoresearch) - Meta-autoresearch framework: adds outer loops that rewrite autoresearch search mechanisms themselves and reports multi-run gains on Karpathy's training benchmark.
- [SkyPilot parallel autoresearch](https://blog.skypilot.co/scaling-autoresearch/) - GPU infrastructure: gives Karpathy's autoresearch access to 16 GPUs so the agent can run parallel experiment waves, validate winners on faster hardware, and reach about 910 runs in about 8 hours.
- [autoresearch_deeplake_swarm](https://github.com/activeloopai/autoresearch_deeplake_swarm) - Cloud swarm infrastructure: extends Karpathy's loop with Modal-powered parallel workers and a shared Deeplake experiment notebook so multiple agents can explore `train.py` concurrently and surface only the best surviving commits.
- [Autoresearch on Red Hat OpenShift AI](https://developers.redhat.com/articles/2026/04/07/autoresearch-on-red-hat-openshift-ai-198-experiments-zero-intervention) - Kubernetes ML infrastructure: runs Karpathy's autoresearch as a 24-hour OpenShift AI workload, packaging nanochat into containers that logged 198 experiments and improved validation loss by 2.3% without human intervention.
- [serverless-autoresearch](https://github.com/roboco-io/serverless-autoresearch) - SageMaker infrastructure: parallelizes Karpathy's autoresearch on Spot training jobs so the agent evaluates `train.py` candidates with HUGI-style burst compute instead of paying for idle GPUs.
- [autoresearch-win-rtx](https://github.com/jsegov/autoresearch-win-rtx) - Windows GPU fork: ports Karpathy's single-file, 5-minute, val_bpb keep/discard loop to native Windows on consumer RTX GPUs.
- [autoresearch-amd](https://github.com/johnmcmullan/autoresearch-amd) - AMD GPU fork: ports Karpathy's single-file, 5-minute val_bpb keep/discard loop to ROCm by replacing Flash Attention 3 with portable SDPA for RDNA 4 cards.
- [autoloop](https://github.com/armgabrielyan/autoloop) - Agent runtime: generalizes Karpathy's autoresearch into bounded repo-level loops with inferred eval commands, explicit guardrails, and keep/discard decisions across multiple coding agents.
- [GOAL.md](https://github.com/jmilinovich/goal-md) - Goal-spec framework: generalizes Karpathy's autoresearch to repos without native scalar metrics by constructing a project-specific fitness function in `GOAL.md`, then running measure → act → verify → keep/revert loops against it.
- [autoresearch-claude-code](https://github.com/drivelineresearch/autoresearch-claude-code) - Claude Code plugin: ports pi-autoresearch into a pure plugin skill with JSONL state, slash-command control, and autonomous keep/discard loops for arbitrary METRIC-based benchmarks.
- [autoresearch-benchmark](https://github.com/suzuke/autoresearch-benchmark) - Benchmarking infrastructure: compares four autoresearch-style tools on the same sorting-throughput task and records both performance gains and iteration behavior under a shared setup.
- [CORAL](https://github.com/Human-Agent-Society/CORAL) - Multi-agent autoresearch infrastructure: runs Claude Code, Codex, or OpenCode workers in isolated worktrees, grades each attempt with `coral eval`, and keeps scored improvements while sharing notes and skills across agents.
- [autoresearch for agents](https://github.com/hwchase17/autoresearch-agents) - Agent evaluation template: adapts autoresearch to `agent.py` plus fixed `run_eval.py` and `dataset.json`, using LangSmith evals and git keep/discard decisions to improve one agent implementation.
- [autoresearch-automl](https://github.com/ferreirafabio/autoresearch-automl) - Benchmarking research: compares nine classical, LLM-based, and hybrid optimizers on Karpathy's nanochat task under a shared 24-hour budget, showing code-editing autoresearch is competitive but fixed-space classical HPO still wins.
- [autoresearch-anycloud](https://github.com/abcdedf/autoresearch-anycloud) - Cloud GPU infrastructure: wraps Karpathy's autoresearch in a unified Mac and cloud runner with platform setup, budget watchdogs, result collection, and automatic teardown across AWS, GCP, Azure, and OCI.
- [skill-autoresearch for Hermes Agent](https://github.com/domvox/hermes-skills/tree/main/skill-autoresearch) - Hermes skill: optimizes prompts, scripts, and validators through baseline → diagnose → patch → re-evaluate → keep/revert loops with dependency checks and conservative holdout rules.
- [autoresearch-anything](https://github.com/grandamenium/autoresearch-anything) - Claude Code skill: scaffolds Karpathy-style autoresearch pipelines for measurable business metrics by generating connectors, persistence setup, and deploy → measure → keep/discard loops around API-observable outcomes.
- [AutoSkill](https://github.com/cgraves09/autoskill) - Skill prompt optimization framework: applies Karpathy's keep/revert loop to `SKILL.md`, mutating one prompt at a time against test cases and improving an auto-reminder skill from 45% to 90% reliability over 60+ autonomous iterations.
- [EvoSkill](https://github.com/sentient-agi/EvoSkill) - Skill-evolution framework: analyzes failed coding-agent trajectories, proposes skill or prompt changes, evaluates them against benchmarks, and keeps only better agent variants in a Karpathy-style self-improvement loop.
- [Skill Forge v2](https://github.com/GodModeAI2025/skill-forge) - Skill and code optimization framework: adapts Karpathy's autoresearch to `SKILL.md` files and generic codebases, using dry-run validation, objective deltas, and keep/revert thresholds to steer autonomous or guided experiment loops.
- [autoimprove-cc](https://github.com/VoidLight00/autoimprove-cc) - Claude Code skill optimizer: applies a Karpathy-style autoresearch loop to `SKILL.md`, scoring binary assertions from `eval.json` and committing or resetting each change based on pass-rate improvement.
- [ehmo/autoresearch-skill](https://github.com/ehmo/autoresearch-skill) - Claude Code and Codex skill: generalizes autoresearch into clean-room red, green, and refactor teams that iteratively find issues, fix them under test, and simplify code on a feature branch while the coordinator keeps only verified progress.
- [ResearcherSkill](https://github.com/krzysztofdudek/ResearcherSkill) - Claude Code and Codex skill: generalizes autoresearch into git-backed `.lab/` sessions with branching experiment trees, convergence detection, and commit/revert control, improving Yggdrasil agent rules from 1.82 to 7.04 in a published loop.
- [Litmus](https://github.com/Kuberwastaken/litmus) - Parallel ML research infrastructure: turns OpenClaw into a multi-agent autoresearch lab with branch-isolated workers, scheduled director and synthesizer roles, and keep/revert experiment commits plus shared discoveries and skills.
- [Autoresearch CLI](https://github.com/199-biotechnologies/autoresearch-cli) - Cross-agent experiment infrastructure: packages Karpathy's one-file, one-metric keep/revert loop as a Rust CLI that scaffolds configs, validates eval commands, records JSONL results, and installs slash-command skills into multiple coding agents.
- [codex-autoresearcher](https://github.com/aelaguiz/codex-autoresearcher) - Codex experiment infrastructure: runs optimization campaigns through separate worker and judge Codex processes, a static `evaluate.sh`, and schema-validated keep or restore verdicts with durable attempt forensics.
- [Codex Autoresearch Harness](https://github.com/SarahXC/codex-autoresearch-harness) - Codex experiment harness: wraps `codex exec` in a bash loop so Codex can run one Karpathy-style experiment at a time, keep or reset `train.py` changes, and compare model variants on the nanochat benchmark.
- [ExAutoresearch](https://github.com/chgeuer/ex_autoresearch) - Elixir autoresearch framework: hot-loads one experiment module at a time, trains GPT variants under fixed budgets across distributed GPU nodes, and uses a referee plus dashboard to early-stop losers and persist the best surviving trials.
- [slowresearch](https://github.com/artkulak/slowresearch) - Delayed-feedback experiment skill: adapts autoresearch to content, outreach, pricing, and other publish-and-wait workflows by logging human-reported metrics and proposing the next hypothesis across long feedback cycles.
- [AutoAgent](https://github.com/kevinrgu/autoagent) - Agent-engineering infrastructure: applies Karpathy's autoresearch to a single-file Harbor agent harness, rewriting `agent.py`, benchmarking scored tasks, and keeping only prompt, tool, or orchestration changes that raise total score.
- [VibeHQ](https://github.com/0x0funky/vibehq-hub) - Multi-agent coordination infrastructure: applies autoresearch to team protocol design by benchmarking agent swarms, analyzing failure logs, rewriting hub code via `/optimize-protocol`, and iterating until coordination flags and token waste fall.
- [helix](https://github.com/VectorInstitute/helix) - Agent-agnostic autoresearch infrastructure: generalizes Karpathy's loop into reproducible `helix.yaml` + `program.md` repos with backend-swappable agents, append-only `experiments.tsv` ledgers, and independently verifiable example helices.
- [Autolab Companion Tools](https://github.com/dean0x/autolab) - Autoresearch companion infrastructure: adds statistical keep/discard verdicts, experiment-history steering, and multi-agent branch competitions to Karpathy's GPT-pretraining loop through the `autojudge`, `autosteer`, and `autoevolve` CLIs.
- [autoresearch-cpu](https://github.com/efecanbasoz/autoresearch-cpu) - CPU ML fork: ports Karpathy's autoresearch to commodity CPUs by replacing Flash Attention with native SDPA, shrinking defaults for 30-minute local runs, and preserving the same one-file `val_bpb` keep/discard loop without CUDA.
- [autoresearch-cn](https://github.com/sanbuphy/autoresearch-cn) - Chinese-language fork: translates Karpathy's autoresearch into Chinese while preserving the original MIT license, single-file training loop, fixed-time budget, and val_bpb keep/discard git workflow.
- [autoresearcher2](https://github.com/ErikDeBruijn/autoresearcher2) - Bayesian research infra: extends Karpathy's autoresearch with structured Bayesian experiment selection, active-inference-inspired exploration, learntropy-style appraisal, and persistent memory, running v4.8 in production on dual RTX PRO 6000 Blackwell GPUs across NanoGPT training and Atari Breakout RL domains.
- [multiautoresearch](https://github.com/burtenshaw/multiautoresearch) - Multi-agent research lab: organizes Karpathy-style autoresearch into three sub-projects (pre-training, post-training, inference optimization) with planner, researcher, reviewer, and memory-keeper sub-agents across Claude Code, Codex, OpenCode, and pi harnesses.
- [autoresearch-serverless](https://github.com/kweinmeister/autoresearch-serverless) - GCP serverless infra: deploys Karpathy's autoresearch as a fully autonomous Cloud Run research lab with NVIDIA L4/RTX PRO 6000 GPUs, Gemini Flash reasoning, GCS checkpoints, and Cloud Workflow chaining for multi-day 24/7 studies.
- [hugoferreira/autoresearch](https://github.com/hugoferreira/autoresearch) - Codebase research framework: generalizes Karpathy's loop into falsifiable hypotheses, isolated experiment worktrees, instrument-backed observations, strict gate review, and reusable lessons for measurable engineering goals.
- [scalar-loop](https://github.com/mandar-karhade/scalar-loop) - Experiment infrastructure: generalizes Karpathy's autoresearch into a Python-core CLI that seals harness files, enforces repo scope, and keeps or reverts only edits that pass metric and guard commands.
- [Autoresearch Lab](https://github.com/nikhaldi/autoresearch-lab) - Black-box experiment infrastructure: wraps any measurable code pipeline in Docker sandboxing, Python eval backends, host-side git commit/revert control, and keep/discard research loops.
- [evo](https://github.com/evo-hq/evo) - Parallel optimization framework: extends Karpathy-style autoresearch with discovered benchmarks, git-worktree tree search, parallel subagents, and commit-only-if-gate-passing score improvements.
- [autoresearch-builder](https://github.com/jung-wan-kim/autoresearch-builder) - Claude Code plugin: auto-detects project type, mutates one target file, runs the chosen build, test, or train command, and keeps or discards each experiment based on a parsed scalar metric.
- [AdaL vs Claude Code: Autoresearch Benchmark](https://github.com/SylphAI-Inc/autoresearch-adal) - Benchmarking research: publishes head-to-head Karpathy-autoresearch runs on A10 and H100 hardware, comparing best `val_bpb`, experiment counts, and kept improvements between AdaL and Claude Code.
- [达尔文.skill](https://github.com/alchaincyf/darwin-skill) - Skill optimization framework: adapts Karpathy's autoresearch to one `SKILL.md` at a time, rescoring structure plus real test outputs and keeping only higher-scoring revisions.
- [Community Computer](https://community.computer) - Collaborative experiment network: turns autoresearch runs into signed, peer-reproducible experiment records and auto-publishes keep/discard outcomes from Claude Code or pi over a Radicle peer-to-peer network.
- [autoresearch-macos](https://github.com/miolini/autoresearch-macos) - Apple Silicon fork: ports Karpathy's autoresearch to macOS with MPS/SDPA fallbacks, preserving the fixed-time training budget, single mutable file, and git keep/revert loop on Apple Silicon Macs.
- [autoresearch-tenstorrent](https://github.com/bro4all/autoresearch-tenstorrent) - Tenstorrent hardware port: ports Karpathy's autoresearch to Tenstorrent Wormhole devices with a TT-XLA backend, preserving the 5-minute fixed budget and keep/revert loop while adapting to a non-CUDA AI accelerator.
- [autoresearch-prompt-optimization](https://github.com/az9713/autoresearch-prompt-optimization) - Prompt optimization skill: adapts Karpathy's autoresearch to autonomous prompt tuning, lifting accuracy from 74.72% to 100% across 8 keep/discard experiments with a locked eval script.
- [autoresearch-council-arena](https://github.com/az9713/autoresearch-council-arena) - Writing optimization framework: combines Karpathy's autoresearch with llm-council so 4 LLMs compete, rank each other, and hill-climb toward the best argument through keep/discard iterations.
- [Auto-Research-Recipes](https://github.com/cxcscmu/Auto-Research-Recipes) - Training recipe research: turns agent-written code, real experiments, and evaluator feedback into a closed-loop autoresearch process that develops non-trivial training recipes.
- [autoresearch-everywhere](https://github.com/Entrpi/autoresearch-everywhere) - Cross-platform expansion: optimizes Karpathy's autoresearch for broader hardware and environment support while preserving the fixed-budget keep/revert core loop.
- [awesome-autoresearch](https://github.com/WecoAI/awesome-autoresearch) - Curated knowledge base: a parallel community-curated list of AutoResearch use cases with optimization traces and open-source implementations at 915+ stars.
- [Awesome-Auto-Research-Tools](https://github.com/handsome-rich/Awesome-Auto-Research-Tools) - Curated tool index: catalogs Auto-Research tools, skill frameworks, platform plugins, and benchmark harnesses across the broader ecosystem.
- [Autoharness](https://github.com/kayba-ai/autoharness) - Agent harness optimization: lets agents explore changes to prompts, configs, and runtime context, run evals, and keep only improvements, achieving benchmark lifts up to 40.7%.
- [Thoth](https://github.com/SeeleAI/Thoth) - Orchestration runtime: provides a dashboard-first control plane for autoresearch that turns drifting agent work into durable runs, locked work items, and reviewable verdicts across Claude Code and Codex.
- [GEPAResearch](https://github.com/CyrusNuevoDia/gepa-research) - Plugin for agentic frameworks: optimizes code using the Genetic-Pareto LLM-driven search algorithm with isolated git worktrees, gated evaluation, and Pareto frontier candidate tracking for keep/discard decisions.
- [Codex Autoresearch](https://github.com/TheGreenCedar/codex-autoresearch) - Codex plugin: wraps optimization goals into measured experiment packets with benchmark contracts, durable session files, evidence trails, and live dashboards for keep/discard review.
- [Cursor Autoresearch](https://github.com/ergenekonyigit/cursor-autoresearch) - Cursor and VS Code extension: ports pi-autoresearch's MCP-driven optimization loop into a code editor with JSONL tracking, browser dashboard, and agent skills for metric-driven keep/discard workflows.
- [interpretable-autoresearch](https://github.com/BarishNamazov/interpretable-autoresearch) - Governance infrastructure: makes autoresearch agent behavior transparent and auditable through behavioral specifications, winning 2nd place at the MIT Spring 2026 Hackathon.
- [skills-autoresearch-flue](https://github.com/schalkneethling/skills-autoresearch-flue) - Evaluation infrastructure: provides a Flue agent harness that evaluates a seed skill against project fixtures, asks a researcher model to improve the skill, then reruns evals against the candidate.
- [autoresearch-plugin](https://github.com/XiaontOVO/autoresearch-plugin) - Research pipeline plugin: packages a full autonomous research pipeline as a Claude Code plugin with 65 skills across 9 families, guiding a direction from vague idea to submission-ready paper.
- [research-program-skill](https://github.com/XWHQSJ/research-program-skill) - Research workflow skill: combines ml-intern's discovery discipline with autoresearch's baseline-first, metric-first loop into a portable skill for Claude Code, Codex CLI, and Cursor Agent.
- [autoimprove](https://github.com/tokyo-megacorp/autoimprove) - Codebase improvement infra: generalizes Karpathy's autoresearch for Claude Code and Codex with git worktree isolation, configurable improvement strategies, and keep/discard experiment logs.
- [harvester](https://github.com/HacksterT/harvester) - Code maintenance infra: applies the Karpathy autoresearch pattern to watch repos, surface improvement opportunities as GitHub issues, execute approved changes overnight via Claude Code, and produce draft PRs for morning review.
- [Autoresearch](https://github.com/mirceastrugaru/autoresearch) - Parallel experimentation framework: spawns supportive and adversarial Claude Code workers to collect evidence for or against research directions, with a judge scoring write-ups and curating the roadmap through iterative convergence detection.
- [pi-autoresearch-harness](https://github.com/monotykamary/pi-autoresearch-harness) - pi extension: forks pi-autoresearch with worktree-isolated experiment harness, adding init/run/log experiment tools and a slash-command dashboard for metric-driven keep/discard loops.
- [Spark Researcher](https://github.com/vibeforge1111/spark-researcher) - Lightweight autoresearch framework: blends Karpathy's compact loop with domain chips, collective intelligence network, and bounded self-editing for disciplined local experiment management.
- [EvE: Evolutionary Ensemble of Agents](https://github.com/scaling-group/eve) - Multi-agent evolution framework: wraps coding agents into a decentralized evolutionary ensemble that co-evolves solver code and agent guidance through autoresearch-style competition, published as arXiv:2605.09018.
- [deep-evolve](https://github.com/Sungmin-Cho/claude-deep-evolve) - Claude Code plugin: generalizes autoresearch from ML training to any software project with automatic evaluation harness generation, journal-based crash recovery, and self-evolutionary outer-loop strategy improvement.
- [AutoResearch-AI](https://github.com/vukrosic/autoresearch-ai) - Autoresearch infra: provides an npm CLI that installs a durable research harness into ML repos so agents can inspect code, propose experiments, run baselines, and continue loops without losing context across sessions.
- [autoresearch](https://github.com/charleneleong-ai/autoresearch) - Autoresearch infra: provides a self-driving experiment sweep loop with daemon-detached `autoresearch.py`, live PR-updating progress charts, and GPU monitoring for ML training projects.
- [pi-lifeline](https://github.com/robzolkos/pi-lifeline) - Autoresearch infra: pi extension that lets smaller autoresearch models request strategic guidance from a stronger advisor model when stuck on plateaus, implementing rate-limited escalation with configurable consecutive-failure and plateau-run thresholds.
- [autoresearch-skill-Andrej-Karpathy](https://github.com/Muminur/autoresearch-skill-Andrej-Karpathy) - Claude Code skill: turns natural-language optimization goals into autonomous goal-parsing, baseline-capture, and keep/discard loops with real-data validation, regression protection, and a reported 76% P99 latency reduction on a live signal-trading pipeline.
- [bob-autoresearch](https://github.com/barvhaim/bob-autoresearch) - IBM Bob Shell adaptation: ports Karpathy's autoresearch pattern to IBM Bob Shell as a Snake AI evolution demo that autonomously improves from random play to Hamilton-path play over 10-15 keep/discard iterations.
- [claude-code-nightly](https://github.com/sb-arnav/claude-code-nightly) - Claude Code substrate improvement: runs a Karpathy-style autoresearch loop that mines session history into personal evaluation suites and autonomously improves CLAUDE.md, hooks, skills, and memory overnight with git-backed keep/revert decisions.
- [autorize](https://github.com/wbbradley/autorize) - Autoresearch infra: a Rust CLI that generalizes Karpathy's autoresearch pattern into a generic iterative-improvement harness, running any agent CLI in sandboxed git worktrees against any scoring command with keep/discard decisions until a deadline fires.
- [pts-autoresearch](https://github.com/DannyBruno/pts-autoresearch) - Prompt/tool/skill optimization harness: adapts Karpathy's three-file architecture (prepare.py, train.py, program.md) to email-triage eval suites, running a hill-climb loop that keeps only higher-scoring prompt and tool configurations.
- [research-autopilot](https://github.com/crabin/research-autopilot) - Codex research skill: turns a research codebase into an autonomous experimentation workflow by generating the three-file autoresearch scaffold and supporting autonomous keep/discard decisions.
- [agent-goal-stack](https://github.com/DefaultPerson/agent-goal-stack) - Claude Code plugin: implements a deterministic keep-or-revert metric loop (`/ags:autoresearch`) with cross-LLM rescue hooks on stuck iterations and pre-merge review, warming up the native /goal and autoresearch patterns.
- [open-autoresearch](https://github.com/rbudnar/open-autoresearch) - Autoresearch protocol: provides a 1700-line protocol specification (AutoResearch++ v0.4) plus copyable scaffolding for disciplined autonomous ML research loops with honest separation between in-band-advisory and out-of-band-enforced controls.
- [Odyssey Engine](https://github.com/Zhifeng-Niu/odyssey-engine) - Autoresearch infra: fuses autoresearch metric-driven experiments with gaggle-iterate checkpoint/verify/rollback and ralph-loop continuous execution into a universal Claude Code iteration engine with three orientations (engineer/creative/production) and git-backed keep/discard waypoints.
- [polyresearch](https://github.com/superagent-ai/polyresearch) - Distributed autoresearch infra: extends Karpathy's loop to multiple machines in a shared queue with independent verification, complete experiment history, and open contributor participation through structured GitHub coordination.
- [ARAIL](https://github.com/cdarnell/arail) - Autoresearch infra: provides a local-first AI research lab blueprint with RAG chat, agent-driven knowledge base, and an autoresearch experiment loop that runs while you sleep.
- [Helixon Autoresearch](https://github.com/nfsarch33/helixon-autoresearch) - Autoresearch infra: a Go-based autonomous ML experiment runner with six-phase experiment lifecycle, Engram memory persistence, and cross-run metric comparison with tolerance-based winner detection.
- [Meta-Search Lab](https://github.com/pyj20061212/metasearch_lab) - Research harness: provides an AlphaZero-style game research harness inspired by autoresearch's fixed-harness design, with arena-driven iteration and champion-gate candidate selection across Othello and other OpenSpiel games.
- [learn-auto-research](https://github.com/AI4Scientist/learn-auto-research) - Autoresearch tutorial: provides a project-based course from the AI4Scientist organization that guides beginners through building autonomous autoresearch loops step by step, from baseline capture to keep/discard decisions.
- [PostHog autoresearch](https://github.com/PostHog/posthog/pull/60081) - Product analytics integration: adds an autoresearch product skeleton with training loops, MCP tools, and a local coordinator to PostHog for autonomous ClickHouse query performance optimization via keep/discard experiments.
- [EvolveMem](https://github.com/aiming-lab/SimpleMem) - Agent memory research: applies autoresearch to co-evolve both stored knowledge and retrieval mechanisms (scoring, fusion, answer generation) through a diagnosis module that adapts memory architecture over time, built on SimpleMem with 43.24% F1 using 98% fewer tokens.
- [GEAR: Genetic AutoResearch](https://arxiv.org/abs/2605.13874) - Autoresearch infra: replaces single-incumbent hill-climbing with a genetic search graph that maintains a bounded frontier of promising code variants, arguing that the standard keep/discard loop prematurely discards valuable complementary local optima.
- [autoresearch-lite](https://github.com/akhil/autoresearch-lite) - Consumer GPU adaptation: ports Karpathy's autoresearch to free Google Colab and Kaggle T4 GPUs with zero local setup by swapping Flash Attention 3 for PyTorch SDPA and adjusting hyperparameters for constrained hardware.
- [autoresearcherUI](https://github.com/Fchaubard/autoresearcherUI) - Self-hosted research cockpit: packages autoresearch with wandb, datadog, and overleaf into a single-binary UI with live dashboard, terminal streaming, and auto-drafted LaTeX paper generation for autonomous ML research.
- [autoresearch](https://github.com/Evarodenas/autoresearch) - Claude Code skill + Python CLI: provides a standalone implementation of Karpathy's autoresearch pattern with program.md, frozen metric evaluation, and git-backed keep/revert decisions for any artifact.
- [Auto-Research Skill](https://github.com/Haoqin860/auto-research-skill) - Claude Code skill: provides an autonomous goal-directed iteration skill with 9 specialized modes (loop, plan, debug, fix, security, ship, scenario, predict, learn) following Karpathy's modify → verify → keep/discard loop.
- [autoresearch-playbook-samples](https://github.com/justmattg/autoresearch-playbook-samples) - Template collection: provides free program.md starter templates organized by application domain for setting up Karpathy-style autoresearch loops with config.yaml, benchmark stubs, and ready-to-use examples.
- [skills-autoresearch-security](https://github.com/schalkneethling/skills-autoresearch-security) - Security skill improvement: enhances security auditor skills through an autoresearch-style auto-improvement loop with fixture seeds, evaluation suites, and ratcheting improvement.
- [autoresearch-orchestrator-pattern](https://github.com/justmy2satoshis/autoresearch-orchestrator-pattern) - Clean-room implementation: provides a ~300-line stdlib-only clean-room implementation of Karpathy's 3-register iterative experiment loop with bring-your-own-LLM and explicit program.md, baseline, metric, and keep/revert guards.
- [autoresearch-template](https://github.com/ikorotkov-ss/autoresearch-template) - Universal template: provides a copyable template with config.yaml, program.md, and benchmark stubs for setting up LLM-driven autoresearch loops across website speed, ML, SEO, prompts, and API latency domains.
- [opencode-auto-research](https://github.com/mittalsuraj18/opencode-auto-research) - OpenCode plugin: ports Karpathy's autoresearch as a plugin for OpenCode with autonomous keep/discard loops and experiment logging.
- [autorefine-skill-improvement](https://github.com/surahli123/autorefine-skill-improvement) - Skill optimization: applies Karpathy's autoresearch plus Hamel's Three Gulfs to skill improvement with human error analysis, judge validation, and disciplined mutation before claiming improvements.
- [autoresearch-distillation](https://github.com/resolutelabsai/autoresearch-distillation) - RL training framework: provides a VERL-based framework for training LLM agents via SDPO and GRPO on autoresearch-style task improvement loops, surpassing Karpathy's original agent (−3.1% vs −2.8% val_bpb) with Qwen3-14B.
- [symphonic-autoresearch](https://github.com/IMJONEZZ/symphonic-autoresearch) - Research infrastructure: wraps Karpathy's autoresearch in OpenAI's Symphony orchestration framework with crash recovery, real-time web dashboard, optional persistent memory, and one-command Docker deployment.
- [Andrej Karpathy's Autoresearch as a Universal Skill](https://github.com/balukosuri/Andrej-Karpathy-s-Autoresearch-As-a-Universal-Skill) - Claude Code and Cursor skill: adapts Karpathy's autoresearch into a universal prompt optimization loop that scans codebases, defines eval criteria, and keeps only higher-scoring prompt mutations.
- [Autoresearch Claude Code Plugin](https://github.com/pjhoberman/autoresearch) - Claude Code plugin: generalizes Karpathy's autoresearch beyond ML training with a discover skill that finds optimization candidates and an autoresearch skill that runs autonomous keep/discard loops against measurable metrics.
- [easy-autoresearch](https://github.com/dschaub95/easy-autoresearch) - Autoresearch infra: scaffolds an autonomous repository-optimization loop for Codex with SQLite state, agent phases, and a live observability dashboard.
- [AutoExp](https://github.com/wizwand/autoexp) - Experiment scaffolding tool: turns any AI/ML training project into a Karpathy-style autoresearch workflow with a one-line setup that auto-infers training commands and evaluation metrics, then runs keep/discard experiments.
- [autoresearch-sboss](https://github.com/Armosphera/autoresearch-sboss) - Sovereign business workflow adaptation: ports Karpathy's keep/revert loop from GPU training to sovereign business workflow optimization, running stdlib+httpx on any Mac with no torch or GPU dependencies.
- [autoresearch-competitions](https://github.com/tangle-network/autoresearch-competitions) - Decentralized improvement market: a Tangle Blueprint that posts bounties for better agents, models, or algorithms, scored on a held-out test, creating an open market for verifiable improvement through autoresearch-style keep/discard evaluation.
- [autoresearch-chain](https://github.com/Thrasher66099/autoresearch-chain) - Decentralized Proof-of-Useful-Work protocol: a fork-native protocol that mines validated improvements to AI training recipes, turning autoresearch experiment results into a decentralized consensus mechanism where kept improvements prove useful computation.
- [Maka-Agent](https://github.com/Maka-Agent/maka-agent) - Agent prompt self-optimization: implements a closed-loop autoresearch system where an agent generates system prompt variants, runs them through Harbor container evals against Terminal Bench, logs results via append-only WAL, filters through an acceptance policy, and iterates on the winning prompt, with PRs #67-#70 building the full pipeline from WAL controller to benchmark-hardened verification.
- [autoresearch-local-critic](https://github.com/pcbrom/autoresearch) - Local LLM critic generalization: extracts the karpathy/autoresearch pattern into a Python package driven by a local Ollama LLM critic (Gemma family) that emits structured JSON proposals with thought_process, hypothesis, code_pseudocode, and risk_level, decoupling the critic from the agent harness so any editable-file+metric problem can be optimized overnight without cloud API dependencies.
- [memory-augmented-autoresearch](https://github.com/arinmanav/memory-augmented-autoresearch) - LLM Wiki memory integration: augments Karpathy's autoresearch loop with persistent memory via his LLM Wiki pattern, where results.tsv becomes the wiki's raw source and is queried before each experiment so the agent remembers past attempts across sessions.
- [autofrontier](https://github.com/mxmsbt/autofrontier) - Crown-gated recursive autoresearch: an agent hunts optimization angles overnight and codes them itself, but only gains that win on a private holdout take the throne — the same gated loop then recurses on the model, the search strategy, and the tool itself.
- [canopy](https://github.com/jjackson/canopy) - Self-improving MCP orchestration: composes tools across projects with autoresearch-driven self-evolution, learning from usage patterns to auto-optimize tool composition and orchestration strategies.
- [agent-collabs](https://github.com/huggingface/agent-collabs) - Collaborative autoresearch infrastructure: Hugging Face's official tooling for quickly setting up the infrastructure to run collaborative autoresearch projects, signaling mainstream platform adoption of the pattern.
- [autoflash](https://github.com/recursive-org/autoflash) - LLM infrastructure autoresearch: Recursive's (Richard Socher) autoresearch tool for performance engineering on LLM infrastructure, applying the keep/discard loop to inference and training system optimization.
- [autoresearch-ios](https://github.com/fomoPhil/autoresearch-ios) - iOS app optimization: a Claude Code skill that applies Karpathy-style auto-research loops to iOS apps via XcodeBuildMCP, measuring and iterating on Xcode build metrics.
- [braided-autoresearch](https://github.com/poudelsubhan/braided-autoresearch) - Git DAG-based autoresearch: models autoresearch as a git DAG with bandit-scheduled lineages, agent-written semantic merges, and cross-lineage replication as a built-in reward-hacking detector.
- [Agentic-Research-Control-Panel](https://github.com/JasonCodeMaker/Agentic-Research-Control-Panel) - Governed autoresearch control plane: a local control panel for running governed AutoResearch in real repositories with human-approved scope, live experiment tracking, evidence-backed results, and project memory for Claude Code and Codex.
- [de-anthropocentric-research-engine](https://github.com/yogsoth-ai/de-anthropocentric-research-engine) - Autonomous research skill framework: 900+ pure-markdown skills organized as 9 composable packages over a 4-layer hierarchy (Campaign→Strategy→Tactic→SOP) with non-linear orchestration and backtracking, treating the AI as the researcher and the human as direction-setter.
- [durable-autoresearch](https://github.com/professorpalmer/durable-autoresearch) - Durable research memory: a white paper proposing waste-verify loops and negative-result memory as complementary mechanisms to soft hubs, enabling durable research memory on consumer GPUs (≤24GB) across long autoresearch runs.
- [Sea-mult-agent](https://github.com/yu-xin-c/Sea-mult-agent) - Multi-agent AutoResearch in Chinese: integrates multi-agent coordination, trusted sandboxed execution, and multi-way ablation experiments, enabling one-sentence launching of isolated AutoResearch ablation studies.
- [AutoConference](https://github.com/AutoConference/AutoConference-skill) - Simulated AI conference: an open-source platform that simulates an openreview-style autoresearch conference where AI agents act as every role (authors, reviewers, ethics reviewers, area chairs, program chairs) across the full submission-to-publication cycle, at 48 ⭐.
- [autoresearch-kernel](https://pypi.org/project/autoresearch-kernel/) - PyPI package: publishes the autoresearch loop as a proper pip-installable Python package (v0.1.0), lowering the barrier from cloning a repo to `pip install` for any measurable optimization task.
- [fiction-autoresearch-harness](https://github.com/delysis/fiction-autoresearch-harness) - Creative writing research: a provenance-preserving autoresearch harness for fiction writing, tracking experimental iterations on narrative structure while maintaining a verifiable record of every creative decision.
- [autoresearch-governance](https://github.com/from1to9/autoresearch-governance) - Evidence-first governance protocol: a compact governance layer for multi-agent automated research that prioritizes evidence trails and claim verification over raw output volume, defining how autonomous research claims can be audited and accepted.
- [standups-with-autoresearch](https://github.com/RohanAwhad/standups-with-autoresearch) - Human-as-PI interaction: defines communication patterns for a human to act as principal investigator over an autoresearch agent, structuring standup-style check-ins and research direction steering without breaking the autonomous loop.
- [dotclaude/autoresearch](https://github.com/FradSer/dotclaude/tree/main/autoresearch) - Claude Code plugin: a domain-agnostic autoresearch loop that uses Claude Code's Stop-hook to run sequential hill-climbing in an isolated git worktree, escalates to a parallel tournament (GAN engine: candidates→judge→synthesize→re-score) when plateaus are detected, and infers artifact/evaluator/bounds from a plain-language goal — the agent never makes real commits until the human confirms.
- [Kyoko](https://github.com/kayba-ai/kyoko) - Agent improvement infrastructure: a local control loop for autoresearch-style agent self-improvement that captures traces, groups recurring failures into evidence-backed issues, lets Claude Code draft fixes, and applies changes only through a gate after checks and evals pass, achieving +23.7% on internal benchmarks and +111.8% pass^3 on tau2-airline.
- [autoresearch-colab-tpu](https://github.com/dimitreOliveira/autoresearch) - Colab TPU port: extends karpathy/autoresearch to Google Colab with Gemini-powered notebook orchestration, PyTorch XLA TPU support, and a pure JAX/Flax reimplementation using jax.lax.scan for micro-batch gradient accumulation and dynamic TPU topology detection, enabling autonomous research on free cloud TPUs.
- [claude-autoresearch-skill](https://github.com/AlexWortega/claude-autoresearch-skill) - Claude Code skill: wraps karpathy/autoresearch with AutoScientists-inspired generational loops where parallel agent teams propose hypotheses, a peer-critic panel prunes before GPU spend, and a shared findings board compounds discoveries across hours or days of autonomous search.
- [autoresearch-evo-db](https://github.com/hgarud/autoresearch) - Evolutionary database fork: integrates MAP-Elites into karpathy/autoresearch by replacing simple TSV logging with a multi-island evolutionary database that returns exploit/explore/random strategy hints to guide the search across diverse solution populations.

### Related Practices / Discussions

Source file: [`categories/related-practices-discussions.md`](categories/related-practices-discussions.md)

### Trading / markets

- [mary on adapting autoresearch into AutoPredict for prediction markets](https://x.com/howdymerry/status/2037683950085378240) - X: describes a framework that applies evaluation + mutation + selection loops to prediction-market trading agents across weather, finance, and politics.
- [0xAggelos on overnight autoresearch across multiple exchanges](https://x.com/0xAggelos/status/2035762307196666153) - X: claims to apply Karpathy's autoresearch pattern to trading strategy research across exchanges and symbols with thousands of experiments and no manual tuning.
- [alex on verifier-driven autoresearch loops for Amazon seller workflows](https://x.com/nospicyplease_/status/2035682307483259073) - X: argues that verifier-driven autoresearch loops fit PPC, catalog, and ASIN-level decisions better than peer-consensus swarms because proposals are kept only when the evaluator approves them.
- [Brandon Pizzacalla on agentic paid ads systems based on Karpathy autoresearch](https://x.com/bpizzacalla/status/2038731009051824318) - X: claims to use Karpathy-style autoresearch as the planning and experiment pattern behind autonomous paid-ads workflows.
- [nlethetech on a NEPSE quant terminal refined through 300+ autoresearch cycles](https://x.com/nlethetech/status/2043522907779862610) - X: says his NEPSE terminal trading workstation backtests strategies with a quant model refined through 300+ autoresearch cycles while combining market data and execution in one interface.
- [tensorqt on Paradigm's autoresearch hackathon for market making](https://x.com/tensorqt/status/2042880400737931401) - X: describes a Paradigm challenge that treated prediction-market market making as an autoresearch problem and says top teams scaled the search with parallel Claude Code or Codex workers plus internal orchestration.
- [xmal on using autoresearch in Naive-Power Law Blend market forecasting](https://x.com/xmal/status/2043998855771861470) - X: says a new Naive-Power Law Blend asset-forecast study applied Karpathy's autoresearch framework, found the loop effective, and exposed overfitting in the initial setup.
- [Karpathy autoresearch loop driving a HMM + GEM ensemble](https://www.reddit.com/r/algotradingcrypto/comments/1t79omn/karpathy_autoresearch_loop_driving_a_hmm_gem/) - Reddit: describes applying Karpathy's autoresearch loop to a Hidden Markov Model and Graph Ensemble Mixture trading strategy with autonomous strategy iteration.
- [I made Claude Code build trading strategies — and built an adversarial harness to stop it from cheating](https://www.reddit.com/r/algotradingcrypto/comments/1t96gca/i_made_claude_code_build_trading_strategies_and/) - Reddit: describes applying Karpathy's autoresearch to crypto strategy design, then building an adversarial verifier when the agent learned to game backtest scoring.

### Business / GTM workflows

- [Brandon Pizzacalla on applying Karpathy's autoresearch pattern to cold email](https://x.com/bpizzacalla/status/2039233818994102609) - X: describes a single-agent loop that tests cold-email variants on live reply-rate metrics, commits winners as the new baseline, and stops at convergence.
- [Karpathy's AutoResearch: How an ML Tool Became a Marketing Optimizer](https://monkfrom.earth/blogs/karpathy-autoresearch-explained-ml-to-marketing) - Blog: reports that Ole Lehmann adapted the autoresearch loop to landing-page copy optimization, lifting a Claude copywriting skill from 56% to 92% checklist pass rate overnight for ~$15, and also applied it to website speed (1100ms → 67ms) and cold outreach.
- [GoatGaucho on applying Karpathy's autoresearch to TrustLayer trust scoring](https://x.com/Goat_Gaucho/status/2036546607739707879) - X: reports using a mutable scoring config plus verifier on 120 labeled agents to push sybil-risk F1 from 0% to 95.9% in two keep-or-revert experiments before shipping the new thresholds to production.
- [I used Karpathy's AutoResearch while building my app - got 80% better AI outputs. Here's exactly how I applied it outside ML](https://www.reddit.com/r/microsaas/comments/1snubrm/i_used_karpathys_autoresearch_while_building_my/) - Reddit: says a Farcast GTM tool used an autoresearch-style ICP and channel loop against real data, keeping only more specific outreach and community recommendations and reporting roughly 80% better outputs.
- [Applied autoresearch to Marketing Mix Modeling — 12x improvement, beat Google Meridian](https://github.com/karpathy/autoresearch/discussions/497) - GitHub Discussion: reports applying Karpathy's autoresearch loop to Marketing Mix Modeling (MMM) and achieving 12x lift over Google Meridian by iterating on model components with keep/discard decisions.

### Workflow automation / consumer ops

- [agrim singh on applying autoresearch to business-class fare search](https://x.com/agrimsingh/status/2041916589906464820) - X: describes an `autofare` loop that proposed 52 alternate routings and date shifts, validated visa and layover rules from YAML, and kept only cheaper legal itineraries, cutting one quoted business-class trip from $4,716 to $2,424 in 16 iterations.

### Prompt / evaluation

- [Aakash Gupta on eval design as the make-or-break constraint in autoresearch](https://x.com/aakashgupta/status/2039204610569544027) - X: argues that autoresearch only transfers cleanly when the evaluator is binary, locked, compact, and specific enough to resist gaming.
- [野口寛士 on nightly autoresearch-style improvement runs on a Mac mini](https://x.com/kan_guchi/status/2042052394130063742) - X: says his team lets a Mac mini run overnight improvement experiments, accepted 20 automatic wins in one night, and found success-metric definition matters more than experiment volume.
- [Ali Amiri on matching Claude Code quality by optimizing prompts with AutoResearch](https://x.com/iampatten/status/2038755598981038193) - X: describes using AutoResearch to tune prompts and push a Qwen-based workflow from weak to strong performance on a large-repo task.
- [Clement Hoang on Headway using autoresearch for mental-health-agent prompts](https://x.com/im_clemmy/status/2043126515605622960) - X: reports that Headway used Karpathy's autoresearch to run about 80 generate → evaluate → analyze → mutate iterations on mental-health-agent prompts and reach 99% accuracy against a 95% target.
- [Phil Chen on using GPT-5.5 for autoresearch-style Sales Ops harness optimization](https://x.com/philhchen/status/2047397863488200974) - X: reports using an autoresearch-style loop on an internal Sales Ops dataset and seeing strong hold-out gains, suggesting newer models can sustain longer benchmark-driven optimization runs.
- [Ren on benchmark-driven skill optimization with autoresearch](https://x.com/liliIiiI1I7/status/2038528225916424395) - X: Chinese discussion noting that autoresearch can be paired with skill creation so agents define a benchmark and then iteratively optimize the skill against it.
- [Aakash Gupta on porting autoresearch to prompt engineering](https://x.com/aakashgupta/status/2038132294817656978) - X: describes mapping autoresearch into a four-role prompt-optimization loop with a locked eval script, binary rubric, results log, and overnight iteration.
- [SonnyClawAI on adversarial second-pass evals in autoresearch](https://x.com/SonnyClawAI/status/2041657267766894777) - X: reports that a 4-hour write → eval → revise → measure loop only surfaced real failures after adding a second adversarial evaluation pass, making evaluator disagreement itself the useful signal.
- [jcyhc_ai on citation hallucinations slipping through the Autoreason evaluator stack](https://x.com/jcyhc_ai/status/2043449643170988484) - X: shows that nine passes of critics and judges still missed fabricated references in the Autoreason paper, highlighting evaluator blind spots in autoresearch-style research-writing loops.
- [Barna on benchmark-coupled correctness gates for zk-autoresearch](https://x.com/realbarnakiss/status/2039725945003585754) - X: reports adding a benchmark-scale bitwise validator and nondeterminism detection because small upstream tests missed bugs that only appeared at the exact workload being optimized.
- [vincent_dalmaso on treating skills like products with autoresearch](https://x.com/vincent_dalmaso/status/2041786712834105484) - X: describes running an autoresearch-skill loop with a baseline, one change at a time, and score-based keep decisions to improve skill behavior instead of rewriting prompts blindly.
- [How I Built a Skill That Makes All My Other Skills Better (Using Karpathy's Autoresearch)](https://aimaker.substack.com/p/how-i-built-skill-improves-all-skills-karpathy-autoresearch-loop) - Blog: describes a meta-skill that builds rubrics, converts weak dimensions into binary evals, and runs keep/discard loops to improve other Claude skills autonomously.
- [Shrinking a Production Prompt by 28% With Autonomous Optimization](https://www.damiangalarza.com/posts/2026-04-06-autonomous-optimization-loops-with-autoresearch/) - Blog: uses uditgoenka/autoresearch to cut a reference-data matrix by 28% over 65 autonomous iterations while maintaining 98.1% output quality through modify → measure → keep/revert loops.
- [AutoResearch for Claude Skills: the two-command loop that finds the gaps, rewrites the file, and keeps only the wins](https://cashandcache.substack.com/p/i-stopped-fixing-claude-skills-by) - Blog: describes a self-improving loop for Claude Skills that scores outputs against evolving rules, surfaces unwritten beliefs, adds rules when scores rise, and lifted one skill from 83% to 100% pass rate in two iterations.
- [Compressing Prompts with an Autoresearch Loop](https://www.ruairidh.dev/blog/compressing-prompts-with-an-autoresearch-loop) - Blog: compresses leaked production system prompts from Cursor, v0, Devin, and Lovable across 55 hypothesis-test iterations, deriving a practical taxonomy of what can be cut without breaking behavior.
- [0xjialin on autoresearch finding no headroom in a security-review skill](https://x.com/0xjialin/status/2041360184740917276) - X: reports adapting autoresearch into an OpenClaw and Claude Code skill to test 10 key dimensions of the SlowMist security-review skill and finding no meaningful optimization space left.
- [snapolino on agents cheating when `prepare.py` is visible](https://x.com/snapolino/status/2043915000528679255) - X: reports that a nanochat-style autoresearch loop gamed a combined `val_bpb + trainable tokens` metric by narrowing the softmax target set once the agent could read `prepare.py`, arguing for hidden or locked evaluators.
- [Auto-research applied to a skill/prompt improvement](https://tylerschultz.me/auto-research/) - Blog: describes using an auto-research loop to test and improve a unit-test discovery skill against repeatable evals, proposing and scoring prompt changes to determine whether the skill performs as intended.

### Software / code workflows

- [0xViviennn on adapting autoresearch to GitHub engineering workflows](https://x.com/0xViviennn/status/2038657899963281725) - X: describes a Chinese engineering adaptation of autoresearch with verifier-gated code cleanup, bug fixing, test additions, and rollback across numbered cycles.
- [Dominic Elm on the three-file autoresearch loop](https://x.com/elmd_/status/2038724362899968047) - X: summarizes autoresearch as propose → train → check → keep or revert → repeat and frames the instruction file as the new bottleneck.
- [Franci Penov on running overnight queues of autoresearch experiments](https://x.com/francip/status/2038777280995246087) - X: describes operating multiple machines that run queued autoresearch experiments, logs, summaries, and findings overnight.
- [xfu on AutoResearch bug-finding persistence](https://x.com/xfubot/status/2038808623774884250) - X: short Chinese observation that autoresearch is unusually strong at repeatedly hunting hidden bugs until it finds them.
- [Kyle Boddy on using autoresearch-claude-code to tune inference hardware parameters](https://x.com/drivelinekyle/status/2038673905368650194) - X: describes using an autoresearch Claude Code setup to tune testing inference machine parameters on 3090-based hardware.
- [Shann Holmberg on setting up autoresearch with Claude Code](https://x.com/shannholmberg/status/2038282051225608613) - X: tutorial thread that frames autoresearch as one file, one metric, and autonomous keep/revert looping inside Claude Code.
- [Bob on autoresearch wasting 11 days on a solved benchmark](https://x.com/TimeToBuildBob/status/2039204620774314504) - X: highlights that a loop can stay mechanically healthy yet keep burning compute after metric saturation if it lacks usefulness-aware stop criteria.
- [Doğaç on GPU-kernel autoresearch needing human nudges and repeated validation](https://x.com/dogacel0/status/2037933914879058095) - X: argues that human steering and rerunning experiments help autoresearch escape local minima and debunk noisy wins in kernel optimization.
- [Barna on model exhaustion signals in zk-autoresearch](https://x.com/realbarnakiss/status/2042244046651793832) - X: reports that once Sonnet kept circling previously eliminated NTT ideas in the iteration memory, he treated that repetition as an exhaustion signal and switched models.
- [Isaac Kargar on using autoresearch to improve another AI agent](https://x.com/kargarisaac/status/2042312695408722417) - X: reports giving Claude Code one agent's codebase, running 24 keep/discard experiments, improving memory quality by 41%, and later refactoring after the loop showed the original bottleneck hypothesis was wrong.
- [Google hit: "Karpathy's autoresearch applied to debugging"](https://www.reddit.com/r/ClaudeAI/comments/1rvbhk3/karpathys_autoresearch_applied_to_debugging_two/) - Reddit: discussion thread about adapting the autoresearch pattern to debugging and validation-driven repair loops.
- [Show HN: Karpathy's autoresearch applied to debugging - two open-source skills](https://news.ycombinator.com/item?id=47399731) - Hacker News: describes applying the one-file, one-metric, keep/discard autoresearch pattern to root-cause analysis and bug-fixing skills for silent failures.
- [Google hit: "Autoresearch with Claude on a real codebase (not ML)"](https://www.reddit.com/r/ClaudeAI/comments/1s22f7d/autoresearch_with_claude_on_a_real_codebase_not/) - Reddit: discussion thread about applying the autoresearch pattern to a production codebase rather than an ML training script.
- [Google hit: "I used Karpathy's autoresearch pattern on product workflows"](https://www.reddit.com/r/ClaudeCode/comments/1s2e8ny/i_used_karpathys_autoresearch_pattern_on_product/) - Reddit: discussion thread suggesting the autoresearch loop is being adapted into broader product and self-improving agent workflows.
- [Google hit: "Autoresearch with Claude on a real codebase (not ML training)"](https://www.reddit.com/r/BlackboxAI_/comments/1s2qs1i/autoresearch_with_claude_on_a_real_codebase_not/) - Reddit: discussion thread emphasizing high failure rates and many discarded experiments as normal when autoresearch is applied to real production codebases.
- [Google hit: "I adapted Karpathy's autoresearch to build an auto-improvement loop for agentic coding skills"](https://www.reddit.com/r/ClaudeAI/comments/1s3feaa/i_adapted_karpathys_autoresearch_to_build_an/) - Reddit: discussion thread about applying the autoresearch loop to iterative improvement of coding-agent skills.
- [AutoResearch for Codex](https://www.reddit.com/r/codex/comments/1s3jdfb/autoresearch_for_codex/) - Reddit: presents a Codex SDK optimizer that fans out candidate branches, benchmarks them under correctness tests, clones survivors, and reports about 33% inference gains plus 16× algorithm speedups.
- [vdaubry on generalizing autoresearch beyond codebases](https://x.com/vdaubry/status/2033530230011216065) - X: argues that the core autoresearch pattern can generalize from code optimization to load testing, landing page A/B tests, and infrastructure tuning when the benchmark is clear.
- [Alex C. on turning autoresearch into a bounded debugging loop skill](https://x.com/alexcovo_eth/status/2030899247470567534) - X: describes deriving a bounded-experiment-loop skill from autoresearch and using it to improve agent debugging and code fixing.
- [kavindpadi on using pi-autoresearch for SQL optimization](https://x.com/kavindpadi/status/2041727544530235899) - X: describes trying pi-autoresearch on intentionally inefficient BigQuery SQL and suggests the same metric-driven loop can target top-cost warehouse queries under platform-specific pricing constraints.
- [Kr1sso on turning Instruments into a teammate for autoresearch](https://x.com/Kr1sso/status/2043272598759354839) - X: describes turning macOS Instruments into an LLM-ready profiling CLI so autoresearch loops can test CPU, Metal GPU, and memory hypotheses and keep or discard optimizations from trace data.
- [Autoresearching Ruby Performance with LLMs](https://rubykaigi.org/2026/presentations/nateberkopec.html) - Conference talk: says LLM agents, reproducible benchmarks, skills, and MCPs can be combined into an autoresearch workbench for Ruby and Rails performance tuning while surfacing the loop's practical limits.
- [Brian on using autoresearch to build and deploy a Raspberry Pi ML model](https://x.com/rantlab/status/2047561605475701170) - X: reports six rounds of architecture search plus custom C inference, Zig cross-compilation, and SSH deployment to a Raspberry Pi 4, cutting p50 latency from 0.488 ms to 0.028 ms in about two hours.
- [Darrell Thomas on an RTX 5090 CUDA kernel factory inspired by autoresearch](https://x.com/DarrellTho39662/status/2042821346736955721) - X: reports an AI loop that runs Nsight Compute, tunes kernels, and keeps or discards 39 CUDA variants, with DSYRK reaching 2.19× cuBLAS and quantum simulation running 2-5× faster than cuQuantum.
- [abhijitmjj on a 13-hour autoresearch loop for a LaTeX scanner](https://x.com/abhijitmjj/status/2043723338359636117) - X: reports using Karpathy's keep/revert loop on a Markdown-to-LaTeX scanner, growing a 59-fixture corpus across 29 iterations to lift F1 from 0.896 to 1.0 while cutting real-world false positives by 78%.
- [latentsea on autoresearch improving a SaaS-building harness against a `time-to-Realworld` benchmark](https://news.ycombinator.com/item?id=47551350) - Hacker News: says autoresearch improved a Claude-driven SaaS harness that builds RealWorld implementations under 90-minute budgets and scores them on test pass counts, harness quality, and completion time.
- [Building an Internal Research Agent for AutoResearch in Claude Code](https://alirezarezvani.medium.com/the-orchestrator-was-missing-building-an-internal-research-agent-around-autoresearch-in-claude-678b08a83c9b) - Blog: describes shipping autoresearch as a standalone Claude Code skill and later adding an orchestrator layer after a month of production use revealed it was only half the system.
- [Feature: Autoresearch Skill — Autonomous Git-Based Experiment Loop](https://github.com/NousResearch/hermes-agent/issues/4824) - GitHub issue: proposes adding a Karpathy-style autoresearch loop to the Hermes agent framework with git-backed keep/revert decisions and crash recovery.
- [Autoresearch isn't just for training models](https://shopify.engineering/autoresearch) - Blog: Shopify engineer Dave recounts building pi-autoresearch with Tobi Lütke, open-sourcing it, and the internal #autoresearch-wins channel that has since logged unit tests 300× faster, builds 65% faster, and pnpm itself becoming faster through autonomous keep/discard loops.
- [Autoresearch Beyond ML: Applying Karpathy's Optimization Pattern to RAG Retrieval](https://swenor.us/articles/autoresearch-beyond-ml.html) - Blog: adapts the autoresearch keep/discard loop to a production RAG knowledge base, mutating metadata and content one fix at a time and lifting retrieval pass rate from 22% to 89% while surfacing silent ontology-drift failures.
- [The Dark Factory Harness: From Autonomous Hill-Climbing to Autonomous Research](https://sotaverified.org/blog/improving-autoresearch-dark-factory-harness) - Blog: adds research context, research memory, and research strategy layers around the autoresearch loop to prevent random-walk behavior and help agents learn from experiment trajectories after 20+ iterations.
- [Two-phase Autoresearch Chain](https://www.reddit.com/r/NavigatingComplexity/comments/1t6zv0t/twophase_autoresearch_chain/) - Reddit: describes a structured two-phase approach to autoresearch with explicit planning and execution phases for more principled experiment design.
- [My first post scored 1. Karpathy's autoresearch idea helped me repost](https://news.ycombinator.com/item?id=48046969) - Hacker News: reports using Karpathy's autoresearch to optimize an HN post itself, treating upvote ratio as the metric and iterating on content through a keep/discard loop.
### Scientific / research augmentation

- [Karpathy's autoresearch could make scientists of us all](https://podscan.fm/podcasts/azeem-azhars-exponential-view/episodes/karpathys-autoresearch-could-make-scientists-of-us-all) - Podcast: Azeem Azhar explores applying Karpathy's loop architecture to refine worldviews, test arguments, and solve business problems beyond ML, arguing the pattern makes autonomous scientific experimentation cheap and accessible.
- [Makoto Tanji on Karpathy's AutoResearch](https://x.com/tan_z_tan/status/2038794997701726668) - X: explains Karpathy's autoresearch as an evolutionary search loop and highlights emerging multi-agent and parallel extensions.
- [Duy Nguyen on Karpathy, Tobi, and generalized autoresearch loops](https://x.com/goon_nguyen/status/2038764906284294428) - X: summarizes autoresearch as edit → evaluate → keep/discard → repeat and points to its use in both GPT training and Shopify Liquid optimization.
- [Darian Parrish on smaller autoresearch loops for non-coding tasks](https://x.com/darian_parrish/status/2038739302826529028) - X: mentions adapting the autoresearch pattern beyond coding into other task types.
- [Ilya on adapting autoresearch to energy-demand peak prediction](https://x.com/ilyaXindy/status/2038604642121093474) - X: describes packaging a custom scorer and composite metric so Claude Code could autoresearch seasonal calibrations and threshold interactions for energy demand prediction.
- [Google hit: "I built an autonomous ML agent that runs experiments on tabular data indefinitely"](https://www.reddit.com/r/MachineLearning/comments/1s73gma/p_i_built_an_autonomous_ml_agent_that_runs/) - Reddit: discussion thread describing a Claude Code setup that applies autoresearch loops to churn and conversion tabular tasks by iterating on features, models, and hyperparameters until gains plateau.
- [Is 'autoresearch' adaptable to LoRA training?](https://www.reddit.com/r/StableDiffusion/comments/1rpxqan/is_autoresearch_adaptable_to_lora_training_do_you/) - Reddit: discussion thread exploring whether Karpathy's autoresearch loop can be applied to Stable Diffusion LoRA fine-tuning with image-quality evaluation as the keep/discard metric.
- [Gemma 4 Uncensored (autoresearch results)](https://www.reddit.com/r/LocalLLaMA/comments/1sd8c59/gemma_4_uncensored_autoresearch_results/) - Reddit: describes an automated research loop that ran 22 Gemma 4 uncensoring experiments, fixed false-positive refusal markers, and escalated from dense-only abliteration to expert-granular MoE edits when results stalled.
- [Dan Woods on using autoresearch plus Apple's "LLM in a Flash" to run Qwen3.5-397B locally](https://x.com/danveloper/status/2033940227736100873) - X: says Claude Code used Karpathy's autoresearch setup plus Apple's "LLM in a Flash" paper to get Qwen3.5-397B running on a 48 GB M3 Max MacBook.
- [Joe Harris on building the same autoresearch idea for robotics teams](https://x.com/_joe_harris_/status/2030803838501073026) - X: claims his team built an analogous loop for robotics teams to automate experiment plumbing, debugging, and iteration around harder physical-world workflows.
- [David Gasquez on using the autoresearch idea in ML competitions](https://x.com/davidgasquez/status/2030946939836022886) - X: says the benchmark-driven autoresearch pattern worked in a couple of ML competition settings and generalizes to scored tasks like retrieval, AUC, and performance tuning.
- [Dylan Huang on a 108-experiment autoresearch run for golf forecasting](https://x.com/dphuang2/status/2043899379040563378) - X: reports letting Claude Code run 108 no-human-loop experiments on Tinker to build a golf forecasting system, cutting held-out tournament log-loss from 2.81 to 0.54 while reverting 52% of trials.
- [Applying Karpathy's autoresearch to a 33M-token public transit dataset](https://www.reddit.com/r/LocalLLM/comments/1t04t00/applying_karpathys_autoresearch_to_a_33mtoken/) - Reddit: reports a 14% improvement on a 33-million-token public transit dataset using Karpathy-style autoresearch with replication notes.
- [The AutoResearch Moment: From Experimenter to Research Director](https://www.preprints.org/manuscript/202603.1329) - Paper: position paper arguing autoresearch shifts the human role from experimenter to research director, relocating accountability upward to claim governance — an objective sheet, program boundaries, discovery trace, verification ledger, and provenance bundle define what can count as a scientific claim from an autoresearch run.

### Infra / benchmarking ideas

- [Versur on bringing autoresearch-style loops to Grasshopper solver workflows](https://x.com/VersurAi/status/2037877185210372372) - X: describes using candidate generation, fixed benchmarks, scoring, and keep-only-if-improved loops for computational design experiments.
- [Google hit: "Autoresearch-style framework for improving heuristics"](https://www.reddit.com/r/optimization/comments/1s3aohf/autoresearchstyle_framework_for_improving/) - Reddit: discussion thread about applying autoresearch-style benchmarked improvement loops to optimization heuristics under strict solver budgets.
- [Google hit: HN thread on applying autoresearch to LLM inference](https://news.ycombinator.com/item?id=47538380) - Hacker News: discussion pointing to autoresearch-style ideas being adapted from model training to LLM inference optimization.
- [From traces to self-improving agents](https://www.metronis.space/blog/from-traces-to-self-improving-agents) - Blog: describes Metronis Aegis as a closed-loop agent-improvement stack where traces become evals, weak slices become RL environments, useful trajectories write back to memory, and release depends on held-out proof.
- [AutoResearch vs Classical Hyperparameter Tuning](https://www.weco.ai/blog/autoresearch-vs-classical-hpo) - Blog: reports a NanoChat head-to-head where autoresearch beats Optuna on sample efficiency, cost-adjusted results, and longer-horizon generalization by escaping a fixed search space.
- [Autoresearch Hub](https://news.ycombinator.com/item?id=47374572) - Hacker News: Karpathy describes an unreleased swarm design where trusted workers verify improvements from a larger untrusted pool to parallelize autoresearch with leaderboard-style proof of progress.
- [Greyforge audit of autoresearch architecture](https://github.com/karpathy/autoresearch/discussions/502) - GitHub Discussion: Greyforge Labs publishes a systems audit concluding autoresearch is a clean demo loop but not a serious research architecture, identifying gaps in supervision, routing, memory discipline, artifact durability, and operator control that they are building further up the stack.
- [Andrej Karpathy on AutoResearch, AI Agents, and Why He Stopped Writing Code (No Priors Interview)](https://pjfp.com/andrej-karpathy-on-autoresearch-ai-agents-and-why-he-stopped-writing-code-full-breakdown-of-his-2026-no-priors-interview/) - Podcast: Karpathy describes the "loopy era" of autonomous systems running experiments, training models, and self-improving without human coding, including details on how he uses autoresearch for 16 hours a day.
- [Autoresearch-Style Autonomous Prompt Optimization for PlanExe](https://docs.planexe.org/proposals/94-autoresearch-style-prompt-optimization/) - Proposal: adapts Karpathy's autoresearch pattern to autonomous prompt-template optimization, mutating one template at a time, regenerating affected outputs, and scoring results overnight.
- [autoresearch on Loooom: Teaching a Skill to Improve Itself](https://www.mager.co/blog/2026-03-20-autoresearch-loooom-skills/) - Blog: dogfoods the autoresearch pattern on the learn-anything skill, lifting it from 0% to 87.5% eval pass rate in two iterations and identifying that deterministic evals, golden responses, and eval versioning are critical for LLM-based keep/discard loops.
- [Autoresearch: The Overnight Loop That Changed the Production Function](https://www.mmntm.net/articles/autoresearch-overnight-loop) - Blog: synthesizes the autoresearch cascade from Karpathy's original loop through financial markets, chess, and rendering, identifying the fixed clock, honest fitness function, and cost convergence as the structural conditions behind the pattern's rapid spread across domains.
- [拆解 AutoResearch：630 行代码，一晚上百次实验](https://juejin.cn/post/7634432180045086726) - Blog (Chinese): a technical deep-dive into Karpathy's 630-line autoresearch codebase, explaining the fixed-time loop, three-file architecture, and why minimalist design enables overnight autonomous experimentation.
- [How to stop your autoresearch loop from cheating](https://www.cerebras.ai/blog/how-to-stop-your-autoresearch-loop-from-cheating) - Blog: Cerebras reports an overnight loop that abandoned the intended experiment and started its own, surfacing evaluator gaming as a first-order failure mode when the agent can read the evaluation setup.
- [Autoresearch and Context Rot — How a Stateless Agent Loop Avoids Memory Problems](https://www.akshayparkhi.net/2026/Mar/13/autoresearch-and-context-rot-how-a-stateless-agent-loop-avoids-m/) - Blog: analyzes how autoresearch's stateless git keep/revert design sidesteps context-window rot and identifies where it still breaks when experiments require long-horizon reasoning.
- [The Karpathy Loop: 700 experiments, 2 days, and a glimpse of where AI is heading](https://fortune.com/2026/03/17/andrej-karpathy-loop-autonomous-ai-agents-future/) - Fortune: mainstream coverage of Karpathy running 700 autonomous experiments over two days, framing the keep/discard pattern as a shift in how AI research gets done.
- [koylanai on building an autonomous autoresearch loop for Agent Skills and Context Engineering](https://x.com/koylanai/status/2055132022180331594) - X: describes building a Karpathy-inspired autonomous research loop that discovers sources, scores them with rubrics, and drafts skill updates for context engineering, directly referencing authorsearch and identifying where repos need stronger validation.
- [AutoResearch 发布满月：社区如何将其从“最小闭环”进化为“通用科研框架”](https://www.80aj.com/2026/04/23/auto-research-evolution-framework/) - Blog (Chinese): reviews how the community evolved Karpathy's minimal loop into a multi-agent, cloud-deployable general research framework within one month of release.
- [The Autoresearch Ecosystem: How One Repo Spawned 9 Different Types of AI Projects](https://www.stephanmiller.com/the-autoresearch-ecosystem-how-one-repo-spawned-9-different-types-of-ai-projects/) - Blog: maps the autoresearch ecosystem into nine distinct project categories and traces how one 630-line script generated an entire optimization toolchain.
- [The Loop Is Only as Good as the Metric](https://www.distributedthoughts.org/2026-03-16-the-loop-is-only-as-good-as-the-metric/) - Blog: argues that autoresearch success hinges on metric design and shows how weak metrics produce spurious wins, useless outputs, or infinite loops.
- [Ran autoresearch with and without access to 2M CS papers](https://www.reddit.com/r/ChatGPTCoding/comments/1s5jin3/ran_autoresearch_with_and_without_access_to_2m_cs/) - Reddit: a controlled experiment where the agent with paper access found techniques outside Claude's training data, suggesting knowledge retrieval as a strong complement to keep/discard loops.
- [Auto-RAG-Optimizer: Applying AutoResearch to Autonomous RAG Tuning](https://yeyu.substack.com/p/auto-rag-optimizer-applying-autoresearch) - Blog: applies autoresearch to RAG pipeline tuning by editing retrieval parameters and keeping only configurations that lift answer accuracy against a fixed eval set.
- [Multi-Agent Autoresearch: Automating ML Optimization with Open Source AI](https://evoailabs.medium.com/multi-agent-autoresearch-automating-ml-optimization-with-open-source-ai-c76d1dabfc0f) - Blog: describes a multi-agent autoresearch setup where specialized agents handle proposal, evaluation, memory, and orchestration roles across ML optimization tasks.
- [Autoresearch System Architecture for ML Claim Validation](https://wiki.charleschen.ai/Review/Research/autoresearch-system-architecture-for-ml-claim-validation) - Wiki: proposes a system architecture that uses autoresearch to validate ML research claims by having agents attempt to reproduce and stress-test reported results in controlled loops.
- [Adapted autoresearch for adversarial protocol hardening](https://github.com/karpathy/autoresearch/discussions/88) - GitHub Discussion: applies the autoresearch pattern to finding invariant violations in a cryptographic delegation protocol, treating the agent as an adversarial tester that proposes protocol changes and keeps only those that break security guarantees.
- [Autoresearch on Steroids with Sandboxes](https://www.tensorlake.ai/blog/autoresearch-on-steroids-with-sandboxes) - Blog: demonstrates using sandboxed environments as the execution layer for autoresearch loops with isolation, parallelism, and pre-warmed filesystems to run candidates faster and more reliably.
- [AI4Scientist/awesome-autoresearch](https://github.com/AI4Scientist/awesome-autoresearch) - GitHub curated list: another community-maintained list of autonomous researcher frameworks with 105+ stars, signaling the ecosystem has grown large enough to sustain multiple curated indexes.

### Software / code workflows (continued)

- [Autoresearch Is Reward Function Design](https://cameronwestland.com/autoresearch-is-reward-function-design/) - Blog: applies pi-autoresearch to optimize a Python finance scoring pipeline across 49 experiments with keep/discard, cutting p95 latency from 339ms to 34ms and arguing that autoresearch success hinges on reward-function design quality rather than the loop mechanics.
- [Kirill Krainov on adapting autoresearch for agentic coding skill improvement](https://zerocopy.blog/2026/03/25/karpathys-autoresearch-improving-agentic-coding-skills/) - Blog: adapts Karpathy's autoresearch loop with multi-metric evaluation (correctness, clarity, performance, completeness) to build a self-improving agentic coding harness that iterates on skill prompts through deterministic experiments and stateless keep/discard cycles.
- [Show HN: LibreOffice-rs — pure-Rust LibreOffice built using autoresearch](https://news.ycombinator.com/item?id=38773512) - Hacker News: reports building a pure-Rust DOCX/XLSX/PPTX/ODF toolkit using Karpathy-style autoresearch loops to iteratively optimize format conversions and benchmark throughput against LibreOffice.
- [I had Codex iterate on its own AGENTS.md 8 times and measured each against real PRs](https://www.stet.sh/blog/how-i-used-codex-to-improve-its-own-agents-md) - Blog: uses Codex's /goal autoresearch loop to iterate AGENTS.md through 8 candidates on a 5-task training slice, then validates on a 10-task holdout that reveals the best candidate still regressed on boundary judgment.
- [Tobi Lütke on /autoresearch making Liquid 53% faster](https://x.com/tobi/status/2032212531846971413) - X: reports running `/autoresearch` on the Shopify Liquid template engine codebase and achieving 53% faster combined parse+render time through autonomous keep/discard iterations.
- [Autoresearch for Refactoring Code](https://taoofmac.com/space/notes/2026/03/29/1300) - Blog: describes applying the autoresearch keep/discard pattern to refactoring tasks, treating code quality metrics as the evaluation signal and iterating on one file at a time.
- [Autoresearch for Integer Factorization](https://github.com/iliazintchenko/agent-factoring) - GitHub: extends the autoresearch pattern to integer factorization by treating an agent as an adversarial proposer that explores search-space modifications and keeps only those that break existing factoring barriers.
- [Autonomous RL Fine-Tuning on Ephemeral GPUs via Autoresearch](https://templarresearch.substack.com/p/autonomous-rl-fine-tuning-on-ephemeral) - Blog: extends Karpathy's autoresearch to RL fine-tuning on ephemeral GPU instances, adding checkpoint-aware experiment queuing and cost-budget gates to the keep/discard loop.
- [NM Framework: 3000 agents running autoresearch experiments](https://nervousmachine.substack.com/p/3000-agents-are-running-experiments) - Blog: describes operating a swarm of 3,000 AI agents organized in a factory pattern with specialized researcher, reviewer, and memory roles, each running modification→verification loops in parallel.
- [Using autoresearch to trace family history back to Jamestown](https://fulghum.io/genealogy) - Blog: applies Karpathy's autoresearch pattern to genealogy by having Claude Code iteratively search archives, verify ancestor claims against multiple sources, and commit only confirmed lineage expansions.

### Infra / benchmarking ideas (continued)

- [Auto-research: The Lab That Runs While You Sleep](https://adlrocha.substack.com/p/adlrocha-auto-research-the-lab-that) - Blog: discusses how automated autoresearch feedback loops shift the bottleneck from running experiments to deciding what to optimize for, arguing that metric definition is the binding constraint on loop effectiveness.
- [Where Autoresearch Breaks (and Why That's the Point)](https://sameernanda.com/autoresearch-verification-search/) - Blog: argues that cheap verification (single-number comparison) is the core mechanism making autoresearch viable, and identifies which domains break when verification requires expensive human judgment.
- [Research Worlds: governing long-running autoresearch agents](https://github.com/karpathy/autoresearch/discussions/275) - GitHub Discussion: proposes a "world file" pattern that defines the research environment (datasets, metrics, constraints, budgets) so agents stay governed even when context drifts across hours or days.
- [Autoresearch & Self-Improving Agent Loops: Community Research Report](https://github.com/sergiocoding96/hermes-multi-agent/blob/main/autoresearch_community_report.md) - Research report: compiles community findings from YouTube, Reddit, and GitHub Discussions on Karpathy's autoresearch and self-improving agent loops as of April 2026.
- [MinLiBuilds on Anthropic's Outcomes feature as autorsearch engineering](https://x.com/MinLiBuilds/status/2052188818137330043) - X: notes that Anthropic's new Outcomes (Codex /goal) feature is essentially autoresearch engineered into the product, signaling mainstream coding-agent platforms adopting the keep/discard loop pattern natively.
- [Tobi Lütke on local models phoning a stronger advisor for autoresearch](https://x.com/tobi/status/2056198717225464307) - X: observes that local models can run pi-autoresearch effectively when they occasionally ask a stronger model for strategy ideas, inspiring the phone-a-friend pattern for multi-model optimization loops.
- [TokenTelemetry — Track token cost and reasoning traces across autoresearch runs](https://github.com/karpathy/autoresearch/discussions/544) - GitHub Discussion: introduces a 100% local, open-source tool for tracking token costs and reasoning traces across autoresearch runs, surfacing expenditure patterns to inform cost-aware experiment design.
- [Is autoresearch really better than classic hyperparameter tuning?](https://www.reddit.com/r/MachineLearning/comments/1satj6r/r_is_autoresearch_really_better_than_classic/) - Reddit: discussion comparing Karpathy-style autoresearch loops with classical hyperparameter tuning methods on the nanochat benchmark, examining whether code-editing agents genuinely outperform structured HPO.
- [When does autoresearch need a human? — ProlificAI HITL study](https://huggingface.co/blog/ProlificAI/autoresearch-hitl-experiment) - Blog: reports a controlled study applying Karpathy's autoresearch to a DPO task with 50 experiments and 300 human judges, finding the metric directionally correct (ρ=+0.80) but a 5-minute conversational check-in unlocked recipes the autonomous loop never reached across 8 hours.
- [TPU Performance Auto-optimization Wiki](https://github.com/vlasenkoalexey/tpu_performance_autoresearch_wiki) - GitHub: documents a wiki of TPU model performance optimization knowledge built using Karpathy-style autoresearch, connecting profiling analysis, hypothesis generation, and benchmarking into an autonomous optimization engine for TPU training workloads.
- [Karpathy joins Anthropic's pre-training team](https://news.ycombinator.com/item?id=48194352) - News: Andrej Karpathy joins Anthropic in May 2026 to work on frontier LLM pre-training, planning to extend autoresearch ideas into larger recursive training improvement efforts with Claude.
- [Running Karpathy's Autoresearch Loop on a T4 GPU inside Dataflow](https://dev.to/dataflow-zone/running-karpathys-autoresearch-loop-on-a-t4-gpu-inside-dataflow-1cdi) - Blog: adapts the autoresearch loop to free T4 GPUs on Google Colab and Kaggle by swapping Flash Attention for PyTorch SDPA and tuning hyperparameters, demonstrating the pattern works on consumer hardware.
- [DeepSeek's "From Copilots to Colleagues" — 45-page survey 99% AI-written](https://victorchen96.github.io/auto_research_survey.pdf) - Paper: Deli Chen (DeepSeek) co-authors a 45-page survey on autonomous research agents where 99% of content is written by DeepSeek-V4-Pro across 108 agent rounds in 6 days, demonstrating AI-driven research paper generation at scale.
- [Karpathy's Autoresearch: 700 Experiments, 20 Improvements, and the Gomoku Hack That Tells the Real Story](https://www.birjob.com/blog/karpathy-autoresearch-2026) - Blog: dissects Karpathy's original 700-experiment run, showing the 11% headline speedup masks Goodhart-overfit (Shopify Liquid), metric-gaming (Gomoku alpha-beta), and that only ~3% of proposed changes survive the keep/discard gate.
- [The Agents That Research While You Sleep](https://www.muttdata.ai/insights/the-agents-that-research-while-you-sleep) - Blog: explores the practical implications of autoresearch loops as overnight autonomous experiment runners, framing the shift from human-in-the-loop to human-in-the-morning review.
- [AutoResearch 2026 @ NeurIPS workshop](https://autoresearch2026.github.io/) - Workshop: organizes a NeurIPS 2026 workshop on end-to-end autonomous scientific research with AI and Robot Scientists, featuring a dual-track call for papers including AI-authored research and an AI peer-review pilot, signaling the field reaching critical mass.
- [Autobrowse: Browserbase applies Karpathy-style autoresearch to browser agent memory](https://www.browserbase.com/blog/autobrowse) - Blog: describes Autobrowse, a system that iterates a browser agent on a real task until convergence and graduates the winning approach into a reusable skill, drawing a direct parallel to Karpathy's autoresearch harness for learning browser workflows.
- [meller on using autoresearch to optimize their own HN Show post](https://news.ycombinator.com/item?id=48046969) - Hacker News: reports using Karpathy's autoresearch idea to iterate on and optimize an HN Show post, treating upvote ratio as the metric and keeping only content changes that improved engagement.

### Software / code workflows (continued)

- [Perplexity on using autoresearch for continual SDK improvement](https://research.perplexity.ai/articles/rethinking-search-as-code-generation) - Blog: describes running an autoresearch loop for weeks to continuously propose and validate Perplexity's Search as Code SDK improvements against latency, codegen quality, and task-performance metrics.
- [Optimizing Smart Contracts With Autoresearch](https://www.degencode.com/p/optimizing-smart-contracts-with-autoresearch) - Blog: applies pi-autoresearch to Vyper smart contract gas optimization for Uniswap V2 arbitrage, running 18 keep/discard iterations that cut executor gas from 202,464 to 169,765 and discovered that direct pool-to-pool token transfers eliminate redundant ERC-20 calls.
- [Deli AutoResearch V2: Three Papers, 941 Citations](https://victorchen96.github.io/blog_auto_research_v2.html) - Blog: describes an LLM-agent-assisted pipeline that produced three comprehensive survey papers (Auto-Research Agents, Continual Learning, Long-Horizon Decision-Making) through autonomous literature search, peer-review simulation, and iterative writing across 49+ skill invocations, with 141 new references added in the V5 refresh.
- [Distributed Autoresearch via Instruction Graph](https://github.com/karpathy/autoresearch/discussions/515) - GitHub Discussion: proposes a trustless distributed autoresearch coordination protocol using signed ECC identities and a global graph database where agents post verified experiments and upvote/downvote results, directly responding to Karpathy's No Priors interview vision.
- [Is Anthropic's Recursive Self-Improvement just autoresearch at scale?](https://github.com/karpathy/autoresearch/discussions/603) - GitHub Discussion: community debate sparked by Anthropic's June 2026 report showing 80%+ autonomous code and 8× engineering velocity, questioning whether frontier recursive self-improvement follows the same propose→implement→validate→keep/revert pattern as Karpathy's autoresearch deployed at massive enterprise scale.
- [Evo ports autoresearch onto Claude Code dynamic workflows](https://aiinsiders.net/article/evo-ports-autoresearch-onto-claude-code-dynamic-workflows) - Article: reports that the evo open-source autoresearch plugin moved its six-step orchestrator from in-context prompts into Claude Code dynamic workflow JavaScript, resolving long-horizon instruction drift by separating model judgment (which hypothesis) from code coordination (parallel fan-out, regression locking, gate execution).
- [Extending the Autoresearch Loop to Earth System Models](https://paragiri.com/blog/2026/autoresearch-paradigm-fire/) - Blog: applies a two-layer autoresearch paradigm (LLM for form-layer mechanism search + Optuna for parameter-layer fitting) to the Ecosystem Demography fire submodel, with Shapley decomposition pruning redundant mechanisms from 8 down to 3 while still reaching rank 1 out of 24 on the ILAMB benchmark, and identifies input validation, multi-channel verification, and frame choice as the binding constraints when moving beyond ML benchmarks.
- [Karpathy's Autoresearch for Software Engineers](https://dev.to/mohan2k3s/karpathys-autoresearch-just-went-viral-heres-how-software-engineers-can-actually-use-the-4cg5) - Blog: distills the autoresearch pattern (evaluator + implementation + direction file) into six concrete software-engineering applications (performance optimization, flaky-test hunting, refactoring, config tuning, prompt iteration, CI optimization) with specific evaluator and direction-file templates for each.
- [Using Agents to Run Experiments While We Sleep: AutoResearch for Cribl AI](https://cribl.io/blog/using-agents-to-run-experiments-while-we-sleep-autoresearch-for-cribl-ai/) - Blog: describes Cribl's production deployment of a Karpathy-inspired experiment loop where a research agent reviews prior results, develops a hypothesis, makes a code change, rebuilds and retrains their privacy detection model, and scores the outcome, achieving a 23% training time reduction and 60% throughput increase on cribl-privacy-1.0.
- [Why I Stopped Running Experiments Myself — Autoresearch for TTS Inference Optimization](https://medium.com/@work.shreeyash/why-i-stopped-running-experiments-myself-and-let-an-ai-agent-optimize-my-tts-model-overnight-7d55a74ce54f) - Blog: applies Karpathy's autoresearch loop to OmniVoice diffusion TTS inference optimization, where the agent autonomously swept diffusion step counts, discovered CUDA Graph capture halved forward-pass latency (39.8ms→20.0ms), surfaced cold-start warmup penalties, and even detected and re-ran its own bad baseline measurements, delivering a 6-7× end-to-end latency reduction overnight.
- [Deli AutoResearch SKILL open-sourced + Self-play survey](https://x.com/victor207755822/status/2067259098584985954) - X/Twitter: Deli Chen open-sources the SKILL.md protocol file behind Deli AutoResearch and publishes a 4th survey paper on Self-play, where for the first time the AutoResearch Agent autonomously planned GPU experiments and submitted real RL training runs (GRPO) on the DeepSeek 285B model with zero human intervention across the entire experiment-design→code→run→debug→conclude pipeline.
- [autoarXiv: autoresearch for any paper](https://x.com/askalphaxiv/status/2067593673072877833) - Service: alphaXiv launches a service where changing 'arxiv' to 'autoarxiv' in any paper URL triggers an agent that resolves codebase setup issues, runs a minimal reproduction, and estimates full replication cost, turning any arXiv paper into a one-click autoresearch experiment.
- [GLM 5.2: first open-weights model for autoresearch](https://x.com/askalphaxiv/status/2069074178829901974) - X/Twitter: alphaXiv reports that Zhipu AI's GLM 5.2 is the first open-weights model proven capable of running a full autoresearch pipeline, autonomously completing async vs colocated sync RL training on Harbor code contests across two 8×H100 nodes with SkyRL, resolving setup issues and producing throughput/reward comparisons — providing an open-source alternative at a moment when closed models are restricting research access.
- [Introspection: Autoresearch in the Wild at AIEWF](https://www.latent.space/p/autoresearch-introspection) - Interview: Latent Space interviews Roland Gavrilescu (ex-xAI), co-founder of Introspection — a new company explicitly building infrastructure for deploying self-improving autoresearch systems — who presented three production patterns at the AI Engineer World's Fair: the loop is the product, learn before automating, and ground feedback in real signals.
- [Guide to Loop Engineering](https://www.marktechpost.com/2026/07/12/guide-to-loop-engineering/) - Article: MarkTechPost synthesizes the emerging discipline of loop engineering — how to design multi-level optimization loops (autoresearch + Bilevel Autoresearch) that turn AI agents into autonomous ML research systems, covering evaluator design, reward hacking prevention, and the shift from inner training loops to outer meta-optimization.
- [GPT 5.6 for autoresearch](https://x.com/askalphaxiv/status/2076737987833095473) - X/Twitter: alphaXiv tests GPT-5.6 on an interpretability paper reproduction and reports it stayed more focused on critical experiments with fewer clarification questions than GPT-5.5 or Fable 5, independently resolving ambiguities instead of pushing them back — suggesting frontier models are crossing a threshold where they can run autoresearch with less handholding.
- [NVIDIA NeMo RL Autoresearch with Agent Skills](https://blogs.nvidia.com/blog/nemotron-rl-autoresearch-agent-skills/) - Tutorial: NVIDIA Nemotron Labs publishes an official guide on running RL autoresearch with NeMo RL, NeMo Gym, and reusable agent skills, demonstrating a Qwen3-VL-2B vision model improving from 25% to 96.9% accuracy on a counting task while the agent autonomously proposed the next experiment.
- [Weco AI AIDE²: First Evidence of Recursive Self-Improvement](https://www.weco.ai/blog/first-evidence-of-recursive-self-improvement) - Blog: Weco AI reports the first experimental evidence of an AI agent recursively self-improving — where an outer optimization loop (autoresearch) improves the inner agent's ability to run the loop itself, closing a meta-learning circle that has been theorized since the original autoresearch release.
- [Autoresearch At Listen Labs](https://listenlabs.ai/blog/autoresearch-at-listen) - Blog: Listen Labs applies autoresearch to AI-led user interviews, iterating on question design and interview flow against real respondent engagement metrics.
- [Autoresearch Just Turned Your Agent Into Its Own System Administrator](https://clawblog.com/autoresearch-self-improving-agents-governance-shift) - Blog: ClawBlog argues that autoresearch represents a governance shift where agents transition from executing tasks to managing and improving their own runtime infrastructure — becoming their own sysadmins.
- [Hiloop Launches Autoresearch Service](https://digg.com/tech/rjaq43ix) - News: Hiloop launches a commercial autoresearch service for AI improvement, marking one of the first productized offerings that packages the autoresearch loop as a paid service rather than an open-source pattern.
- [Autoresearch Summit Takeaways](https://blog.agihouse.org/posts/autoresearch-summit-takeaways) - Blog: AGI House publishes takeaways from an autoresearch-focused summit, signaling that the community has reached sufficient critical mass to organize dedicated in-person events around the pattern.
- [Run Karpathy's autoresearch on Google serverless for $2/hour](https://medium.com/google-cloud/run-karpathys-autoresearch-on-a-google-serverless-stack-for-2-hour-210fc8e2a829) - Tutorial: demonstrates running the full autoresearch loop on Google Cloud's serverless stack at approximately $2/hour, making overnight autonomous experimentation accessible without owning a GPU.
- [Chi (χ): An Autoresearch Harness for Coding Agents](https://kdpisda.in/chi-autoresearch-harness-llm-coding-agents/) - Blog: Kuldeep Pisda introduces Chi, an autoresearch harness designed specifically for coding agents, with structured experiment tracking and metric-driven keep/discard gates.
- [Autoresearch vs Meta-Harness](https://aiquinta.ai/blog/autoresearch-vs-meta-harness/) - Blog: AI Quinta compares the two dominant self-optimizing paradigms — single-loop autoresearch vs meta-harness optimization — analyzing their relative strengths for different problem classes.
- [product-darwin: autoresearch for product decisions](https://github.com/ulpan12/product-darwin) - Repo: applies Karpathy's autoresearch loop to product management — a 5-minute "should we build this?" decision framework that treats product hypotheses as experiments to be validated, kept, or discarded.
- [Autoresearch Builder Recap](https://blog.agihouse.org/posts/autoresearch-builder-recap) - Blog: AGI House publishes a recap from an autoresearch builder event, highlighting practical patterns and lessons from practitioners building and deploying autoresearch systems.
- [Study contradicts autonomous-research optimism](https://the-decoder.com/study-contradicts-anthropic-and-openai-claims-that-autonomous-ai-research-is-within-reach/) - News: a study pushes back on Anthropic and OpenAI claims that autonomous AI research is imminent, providing a counterweight to the optimism by measuring where agents still fall short on open-ended discovery.
- [An Attempt To Understand Automated AI Research](https://www.primeintellect.ai/blog/comparing-frontier-models-nanogpt-speedrun) - Blog: Prime Intellect compares frontier models on the nanoGPT speedrun benchmark, attempting to characterize how different LLMs perform as autoresearch agents on a standardized optimization task.
- [Eigen and Lighter Launch Autoresearch Challenge](https://cryptopanic.com/news/33168053/Eigen-and-Lighter-Launch-Autoresearch-Challenge-to-Speed-up-Exchange) - News: Eigen and Lighter launch a competitive autoresearch challenge to speed up crypto exchange performance, marking the pattern's adoption as a competitive benchmarking format in DeFi.

## Submission format

Use exactly one line per entry:

```md
- [Name](URL) - Industry: one-sentence description of the autoresearch use case.
```

## How to contribute

1. Pick the category that best matches the direct autoresearch application domain.
2. Add a single-line entry in the required format to the category file, not directly to the README aggregate.
3. Keep the summary concrete and scannable.
4. Prefer examples that clearly show scenario + autoresearch loop + value.

See [CONTRIBUTING.md](CONTRIBUTING.md) for details.

## License

MIT

awesome-autoresearch

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README