AI Research

Machine Learning Systems30.0k★

Machine Learning Systems is a free textbook from Harvard's CS249r course. It's not a tool you install. It's a book you read at mlsysbook.ai. Covers the full ML systems stack: hardware architectures, model optimization, deployment on microcontrollers, on-device training, benchmarking, and security. Written by Harvard professors with contributions from industry practitioners. Regular updates as the field moves. Fully free. No paywall, no premium chapters, no course enrollment required. The entire book is available online at mlsysbook.ai and the source is on GitHub. This is for anyone from students to senior engineers who want to understand ML systems beyond 'call the API.' If you're deploying models to production and don't understand quantization, pruning, or hardware-aware optimization, this fills that gap. The catch: it's an academic textbook. The writing is thorough but dense. If you want a quick practical guide to deploying a model on a Raspberry Pi, this will give you the theory but not the step-by-step tutorial. And the attention it gets is mostly students bookmarking the repo; the GitHub activity doesn't reflect active development in the traditional sense.

tinyrenderer24.5k★

This isn't a tool you install; it's a course. Tinyrenderer teaches you how 3D rendering actually works by having you build a software renderer from scratch in C++. No GPU, no OpenGL, no libraries. Just math and pixels. You start with drawing lines, move to triangles, add textures, implement lighting, build a z-buffer, and by the end you've written a basic 3D engine that can render textured, lit models. The whole thing is about 500 lines of code. Each lesson has theory, code, and visual output so you can see what each step does. Completely free. The lessons are in the GitHub wiki. The code is public. No paid tier, no course fee, no upsell. One of the most popular computer graphics educational resources on GitHub, and it's been a go-to in graphics education for years. The catch: this is not for beginners who've never coded. You need to be comfortable with C++ (or at least C-like syntax) and basic linear algebra (vectors, matrices, dot products). If that sounds intimidating, start with a gentler intro to graphics programming first. This teaches software rendering, useful for understanding how GPUs work, but you won't use this approach in production. For actual 3D work, you'll move to OpenGL, Vulkan, or a game engine.

Auto-claude-code-research-in-sleep18.8k★

ARIS (Auto-Research-In-Sleep) is a free MIT pack of Markdown skills that turns Claude Code into an overnight ML research assistant. Give it a direction, or a paper plus code, and it finds ideas, runs experiments, writes the paper and drafts rebuttals. The twist: Claude does the work and a different model, GPT via the Codex CLI by default, reviews it, since a model grading itself misses its blind spots. Setup: clone the repo, link 80-plus skills into your project, register the Codex reviewer over MCP. Papers need LaTeX; experiments need a GPU over SSH, a local card, Vast.ai or Modal. It also runs in Codex, Cursor or its own CLI. No paid tier, but models cost money. By default it rides your Claude Code and ChatGPT logins, so a night burns plan quota. On API keys, Claude Opus 5 is $5 per million tokens in and $25 out, and the review loop runs up to four rounds by default, plus GPU time. Solo researchers and small labs: worth it. Larger teams: no shared service. The catch: overnight runs mean pre-approving file writes, and the loop chases a reviewer's score, not the truth. Check every claim and citation before submitting.

AutoResearchClaw14.8k★

AutoResearchClaw automates research by letting AI agents search, analyze, and synthesize information from multiple sources, then compile structured reports on the results. You give it an idea, it designs experiments, runs them, writes the paper, and iterates on the results. Basically a research assistant that never sleeps. It's built for academic and ML research specifically, not general-purpose AI automation. The pipeline handles literature review, experiment design, code generation, result analysis, and paper writing in a loop. The catch: this is bleeding edge. It moves fast, but it is a research tool built by a research lab. The output still needs human review; don't submit a paper without reading it. And the quality depends heavily on the underlying LLM you point it at.

pi-autoresearch8.2k★

Research loops are mostly babysitting: change a parameter, run it, read the output, change it again. Pi-autoresearch takes you out of that loop. You define an experiment, walk away, and it cycles through modify, test, and evaluate until it converges on a result. This is the same autonomous research pattern as ARIS and autoresearch, but built specifically for pi's ecosystem. The integration is tighter because it is native to the harness rather than a bolt-on. MIT licensed, TypeScript. Pi itself is an open source agent harness, so there is no platform subscription behind this. The recurring cost is your own model API key, and an autonomous loop that keeps modifying and re-testing will spend more of it than you expect. Cap the iterations before you walk away. The catch is portability. This is built for pi and only pi. Move to Claude Code or Codex and you leave it behind, which is a real consideration for a tool whose whole value is unattended runtime.

autoresearch6.8k★

Autoresearch turns Claude Code into a relentless iteration machine. You set a goal, point it at your codebase, and it runs a modify-verify-keep-or-discard cycle until the goal is met or you pull the plug. Inspired by Karpathy's approach to autonomous ML research, it generalizes that pattern to any domain where you can write a test for success. This isn't a framework you build on. It's a skill you add to Claude Code, so setup is dropping it into your skills directory. The work happens inside the loop: it proposes a change, runs your verification, and only keeps what passes. You define what done looks like, then walk away. Solo developers and researchers who already live in Claude Code get the most here, a way to throw a well-scoped, testable problem at an agent and let it grind. Teams without a clear success signal get less, because the loop is only as good as the check it runs against. The catch: it lives entirely inside the Claude Code ecosystem, so you need that subscription. And autonomous iteration burns API credits fast. Give it a fuzzy goal or a slow test and it will happily spend your money chasing its tail. Scope it tight and watch it.

PRAXIST5.5k★

Praxist runs research as a long-lived process instead of a chat session. You point it at a project that already runs and has a measurable objective, and it coordinates parallel research agents, evaluates each one against a task-owned scoring function, keeps durable evidence of what was tried, and carries findings from one generation of attempts into the next. The pitch is a personal R&D team rather than a coding assistant. Setup is real work. It is a Python 3.11+ install with agent and Codex extras, an interactive wizard covering license acceptance, credentials, and readiness checks, then a separate takeover step that creates a project contract before any research runs. It works with a Codex subscription and no API key, or against open source model APIs, which the docs recommend for sustained runs because of the cache-hit rate. Long autonomous runs mean real token spend regardless of who serves the model. Free for individuals and companies under $1,000,000 in annual revenue. Cross that line and you need a paid commercial license from Sapient Intelligence. Solo researchers and small teams pay nothing today. Anyone at scale needs to price the license before building on it. The catch is that this is Fair Source, not open source. You may use and modify it internally, but you may not redistribute, sublicense, or resell it, and the revenue threshold follows your whole company. That is a legal review, not a pip install.

SemIf4.9k★

SemIf is the open source answer to Jev, the closed decision model TypeSafe AI launched in September 2026. Jev's trick is returning typed decisions (pick one, score this, yes or no) instead of generated text. SemIf gets the same interface out of ordinary open models by reading the model's probabilities for each allowed option directly, skipping text generation. MIT licensed, formerly called OpenJev. It runs on hardware you own: a CUDA GPU that can hold a 4B model (the README's reference is an RTX 3090), Apple Silicon through a native MLX backend, or in the browser over WebGPU with models from 639 MB to 3 GB. Install is pip from source plus a Hugging Face model download. No Jev key, no account. On the author's 21-criteria test, direct scoring took about one second against more than five for generating JSON the usual way. Free at every size. For builders, this is a way to try the decision-model pattern in a classifier, router, or guardrail without joining a waitlist. Laya is the other open option, a purpose-trained model instead of a technique. The catch: it copies the interface, not the model. The author never ran a live Jev endpoint, the agreement figures come from a small selected sample, and the fast reuse paths are marked experimental. No releases yet. Calibrate it on your own workload before it decides anything real.

openscience4.3k★

OpenScience is an AI agent built to run the actual research loop. Point it at a goal and it reads the papers that matter, forms a hypothesis, writes and runs code, executes experiments, queries databases like UniProt, PDB, arXiv, and Semantic Scholar, and writes up what it found. It is open source (Apache 2.0) and model-agnostic. Bring your own API key from Anthropic, OpenAI, Google, or dozens of other providers and the whole thing runs free, no account required. Install is a single npm command, and it opens a full workspace in your browser: file tree, editor, terminal, session history, plus inline rendering for molecules, structures, and plots. There is no server to run or database to manage. The real cost is whatever API usage you rack up with your chosen model provider, which for a long research session with a frontier model adds up fast. Solo researchers and small labs can run this entirely on bring-your-own-key pricing. The optional paid layer is Atlas, Synthetic Sciences own managed platform: a prepaid wallet for a curated set of frontier models plus cloud compute, so a team does not need to juggle five providers API keys or provision its own GPUs. Solo: free. Small teams: free or Atlas if you want managed compute. Larger teams doing heavy experimentation: Atlas is the easier path. The agent is not sandboxed. It runs shell commands and edits files with the permissions you give it, so if you are pointing it at real infrastructure or sensitive data, run it in a container or VM. The permission system tells you what it is doing, it does not stop it from doing something you did not mean to allow.

marin4.1k★

Marin is an open recipe for training foundation models from scratch. Not just the finished weights, the whole pipeline: data curation, filtering, tokenization, pretraining, posttraining, and evaluation. It is Apache-2.0, and the thing that sets it apart is radical openness. Every run's checkpoints, data mixtures, and decisions get published, failed experiments included. This is not a weekend project. It is built for serious compute, trained on Google's TPU Research Cloud, with the current focus a mixture-of-experts model north of 500 billion parameters. Realistically you use it two ways: as a library to run your own experiments (people have already forked it for DNA and protein models), or as a reference to learn how frontier models actually get built. Running the full recipe means real cluster time and a real compute bill. Who it is for: researchers and teams who want a documented, reproducible path to training models, not an API to call. A solo builder who just wants to use a model should skip this and reach for an inference tool. Labs, grad students, and companies doing pretraining research get one of the most transparent open frameworks going, and the write-ups alone are worth the read. The catch: the software is free, the compute is not. Reproducing even the smaller runs assumes access to TPUs or a comparable cluster. Marin's value is the openness and the methodology, not a shortcut around the hardware bill.

tribev23.3k★

TRIBE v2 is a research benchmark from Meta AI for evaluating video understanding models, specifically how well AI can track multiple objects across video frames. If you're doing computer vision research on multi-object tracking, this provides training code, evaluation tools, and pretrained models. Jupyter Notebook-based, CC BY-NC 4.0 license (non-commercial use only). The benchmark includes datasets and evaluation protocols that let you compare your tracking model against established baselines. The catch: non-commercial license means you cannot use this in a product. It's for research evaluation only. Requires significant GPU resources to run the training and evaluation pipelines. And as an academic benchmark, it's designed for researchers who already understand multi-object tracking. Not a tool for building applications.

HyperAgents2.9k★

A 'meta agent' modifies the 'task agent' and can also modify itself. It's agents all the way down. The architecture combines a task agent (solves the problem) and a meta agent (optimizes both the task agent and its own optimization strategy) into a single editable Python repository. The meta agent can modify any file, including its own source code. In benchmarks, this self-referential loop outperforms agents without self-improvement, and the meta-level improvements transfer across domains. This is from the paper 'Hyperagents' (arxiv 2603.19461). The catch: this is a research project, not a production tool. The license says 'Other' which likely means Meta's research license. Check before using commercially. Running self-modifying agents requires serious compute (the paper uses multiple LLM calls per iteration) and serious trust in the guardrails. Fascinating research. Not something you deploy to production tomorrow.

HRM-Text2.3k★

HRM-Text is a pretraining framework for building your own small language model from scratch, cheaply. The claim is foundation-model pretraining with 130 to 600 times less compute and far less data than usual, using a Hierarchical Reasoning Model architecture instead of a standard transformer. Apache-2.0 and free, with a pre-trained 1B checkpoint on Hugging Face if you'd rather not train. This is research infrastructure, not a product. It's a full training pipeline: prepare tokenized data, launch distributed training, evaluate on benchmarks like MATH and MMLU, export to Hugging Face format. The architecture leans on recurrent reasoning layers, sequence packing, and FlashAttention 3 kernels to squeeze efficiency out of the run. The catch: cheap is relative. You still need a cluster of 8 to 16 H100 GPUs and roughly 800 to 1,500 dollars in compute for a full training run. This is for researchers and teams exploring efficient architectures, not for anyone who just wants to use a model. If that's you, grab the checkpoint and skip the training code.

handwired2.1k★

Handwired turns program logic (if-else, comparisons, loops, state) into the math a neural net runs: weighted sums and ReLU. The weights are written by hand, not learned, so results are exact with no training, and because everything stays differentiable you can later unfreeze those weights and train them. It's a free, MIT-licensed research project from Cheng Lou, who also wrote the Pretext text-layout library. The tagline says it turns your regular JavaScript into a neural net. Its own docs say otherwise: "No tool converts existing JavaScript source into a program." You rewrite the logic by hand in builder code, calling functions like emitCompare that append operations. Loops can't exit early, so they become counts, trees or tables. Setup is a clone, bun install, bun start. It isn't on npm. Programs run in JavaScript on the CPU; only the demo that searches 100,000 JSON documents per keystroke uses WebGPU. Solo: worth an afternoon with the demos. Small and larger teams: nothing to ship yet. Free, no paid tier. The catch: it's a days-old lab, not a library. No package, no stable API, and an evaluation throws when a value leaves its declared range.

open-science2.1k★

Open Science Desktop is the free, MIT-licensed answer to Anthropic's Claude Science: one desktop app for the whole research loop, from literature survey and hypothesis to experiment code, figures and the paper. Every figure, table and notebook links back to the code, inputs and conversation that produced it. You bring your own model. A bundled OpenCode runtime talks to whatever provider you pick. Runs can target your laptop, SSH or Slurm clusters, or your own Modal account, and osd server puts the same web UI on a machine with no screen. The macOS build is signed and notarized; Windows and Linux builds aren't signed yet. Nothing to buy. Claude Science requires a paid Claude plan; this needs only your model bill, and paper-length agent sessions burn tokens. Solo researchers and grad students: free. Labs: free, and data stays in local folders. Larger groups: free, with API spend as the line item. The catch: it's version 0.6 and calls itself beta. The agent can drive your real Chrome profile with your logins, operate desktop apps on your screen and submit cluster jobs, so keep the default approvals on. Its main sponsor, APEVON, also sells a paid research app, Apevon Science.

ToolUniverse1.8k★

ToolUniverse hands an AI agent a library of more than a thousand scientific resources: datasets, machine learning models, and APIs spanning literature search, chemistry, genomics, and clinical data. Rather than writing a custom wrapper every time you want an agent to query PubMed or run a property prediction, you point it at ToolUniverse and it discovers what is available. Apache 2.0, out of a Harvard lab. Four ways in, with a wide difficulty spread. Run it as an MCP server and wire it into an existing agent with a config block, install it as a skill with npx skills add, use the Python SDK, or drive the tu CLI. The MCP path is the one most people should take. Nothing to host, but you inherit whatever API keys and rate limits the underlying catalog requires, and that is where the actual setup time goes. Academic researchers and biotech teams building agentic workflows are the target, and the fit there is real. There are 68 pre-built research workflows to start from. General software developers will find most of the catalog irrelevant, because this is scientific tooling specifically, not a general-purpose tool registry. Free at every team size. The catch: a thousand tools is a headline number, not a quality guarantee. Coverage is uneven, some endpoints are academic services with no uptime commitment, and an agent picking from a menu that large fails in ways that are miserable to debug. The project knows it and ships Compact Mode, which collapses the catalog down to four or five discovery tools. Use it.

Commerce Agent Bench1.3k★

Commerce Agent Bench, renamed from RealReplicaBench, tests whether an AI agent can finish real business work instead of just talking about it. Its 107 tasks (publishing products, booking freight, editing storefronts) run against local replicas of commerce and SaaS systems, each graded by its own verifier. Code is Apache 2.0, tasks CC BY 4.0, both fine for commercial use. Running it takes Python 3.11+, Docker on linux/amd64, a pinned OpenClaw image, an API key for the model under test and a second key for the LLM judge. The real bill is tokens: the published runs averaged between 0.8 million and 11 million tokens per task depending on model and harness. This is an instrument for teams building agents or choosing models, not something you deploy. Accio will run your model on request, with no published pricing. OSWorld, WebArena and tau-bench are the peers. The catch: Alibaba's Accio team builds the benchmark, and its own Accio harness competes on the leaderboard. The published scores came through Accio-managed endpoints and the raw task-level results aren't public yet, so you can't reproduce the board run for run. Mocks also measure skill against Accio's model of these services, not the real ones.

OpenGauss1.3k★

OpenGauss is the best open source tool for enterprise Postgres right now. It's a workflow orchestrator from Math, Inc, that gives the Gauss AI agent a multi-agent frontend for proof engineering: proving, drafting, auto-proving, formalizing, and auto-formalizing. On FormalQualBench, it beats Harmonic's Aristotle agent (which has no time limit) running with just a 4-hour timeout. You can stay interactive or let it run autonomously, coordinate subagents in parallel, and inspect everything. MIT licensed. Built in Python. The catch: this is an extremely niche tool. If you're not doing formal mathematics or proof verification in Lean, this does nothing for you. The audience is mathematicians, formal methods researchers, and teams building verified software. Math, Inc. is pushing the frontier here, but the Lean ecosystem itself is still small compared to mainstream programming languages.

autoresearch-genealogy1.2k★

This gives you structured prompts, Obsidian vault templates, and archive research guides specifically for genealogy work with Claude Code. It's not a tool you install. It's a research methodology packaged as Claude Code skills. You get templates for organizing findings, prompts that know how to search genealogy databases, and guides for navigating archives like Ancestry.com, FamilySearch, and government records. MIT licensed. The catch: this is a niche application of AI research skills. If you're not doing genealogy, it's useless. The quality of results depends heavily on what records are available online. AI can't access physical archives or read handwritten documents that haven't been digitized. And it's prompts and templates, not a tool. The actual research still requires human judgment about which sources to trust.

Qwen-AgentWorld1.0k★

Training an AI agent needs somewhere for it to practice: a terminal that talks back, a website it can click through, a phone screen it can tap. Standing all that up for real is a pain. Qwen-AgentWorld is a model that fakes it. It is a language world model from the Qwen team that simulates how environments respond to an agent's actions across seven domains: terminal, web, Android, software engineering, search, OS, and MCP. The weights are open under Apache 2.0, free to download from Hugging Face or ModelScope. This is not a pip-install-and-go tool. It is model weights, which means you serve them yourself with something like vLLM or SGLang, or load them through Hugging Face Transformers. That is real GPU infrastructure, not a laptop job. Once it is up, you can run inference, score agents against the bundled AgentWorldBench, or fine-tune it for your own domain. The plumbing is standard if you have served an open LLM before, and a wall if you have not. This is for teams building or evaluating agents who want a reproducible, offline environment instead of hammering real systems. If that is you, the price is right: free weights, free benchmark, run as many evals as your GPUs allow. If you are not training agents, there is nothing here for you yet. It is research infrastructure, not a product. The catch is that a simulated world is a guess. A model predicting what a terminal would print, or how a webpage would react, can be confidently wrong, and an agent that trains against a wrong simulation learns the wrong lesson. Treat it as a fast, cheap first pass, not a substitute for testing against the real thing before anything ships.