AI Research

Machine Learning Systems28.3k★

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.3k★

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-sleep16.3k★

ARIS (Auto-Research-In-Sleep) automates ML research overnight. You give Claude Code a research question or experiment, walk away, and come back to results, with cross-model review gates designed to catch hallucinations and fabricated citations along the way. It's a Markdown-only skills bundle, no framework, no lock-in. Claude Code is the driver, but the review loop pulls in GPT, DeepSeek, and other providers to check each other's work. The skill set (67+ bundled) covers literature review, idea discovery, experiment automation, paper writing, and rebuttal drafting. MIT licensed, with hardening that came from real NeurIPS submission cycles, not vibes. Solo ML researchers and small academic teams running into the same paper-writing grind every conference cycle get the biggest win. Industry research teams with full MLOps platforms probably don't need this. The cross-model review piece is the differentiator. Most overnight-agent setups skip it and ship hallucinated citations. The catch: autonomous overnight loops only work if your constraints are tight. Vague goals produce vague output and burn through credits. And the cross-model review means every iteration costs multiple LLM calls instead of one. Budget accordingly, especially if you're routing to GPT or Claude Opus for the reviewer role.

AutoResearchClaw14.5k★

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.1k★

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.

canvas-lms6.8k★

Canvas LMS is what universities and K-12 schools actually use. It's the open source version of the same platform that Instructure sells commercially to thousands of educational institutions. AGPL-3.0, written in Ruby on Rails. You get the full LMS: course management, a gradebook, discussion boards, a calendar, file storage, video conferencing integration, and LTI (Learning Tools Interoperability) support for third-party tool plugins. Self-hosting is free under AGPL. Instructure sells the hosted version (Canvas Cloud); pricing is per-institution and not publicly listed, but think five to six figures annually for universities. The catch: self-hosting Canvas is a serious undertaking. It requires Ruby on Rails, PostgreSQL, Redis, a job queue, file storage (S3 or local), and real ops knowledge. The AGPL license means any modifications you make must be open sourced if you offer it as a service. And without Instructure's support, you're on your own for updates, security patches, and integration issues. This is enterprise software that happens to be open source, not a weekend project.

autoresearch6.3k★

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.7k★

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.

marin3.7k★

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.

openscience3.6k★

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.

SemIf3.4k★

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.

kana-dojo3.4k★

Kana Dojo is a minimalist Japanese language learning app inspired by Duolingo, built with Next.js. Covers hiragana, katakana, and vocabulary with spaced repetition. Clean UI, gamified progress tracking, and a focus on the fundamentals that trip up beginners. Fully free, no ads, no paid tier. Sponsored by Vercel. The codebase is beginner-friendly with labeled good-first-issues, so it doubles as a learning project for Next.js developers. The catch: Japanese only. No other languages supported, and the curriculum covers kana and basic vocabulary, not grammar or conversation. If you're past the beginner stage, you'll outgrow it quickly. For comprehensive Japanese learning, Anki with community decks goes much deeper.

tribev23.2k★

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.7k★

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.0k★

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.

ToolUniverse1.7k★

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.

open-science1.7k★

Open Science Desktop turns the AI-for-science workflow into one desktop app: literature survey, hypothesis, experiment code, figures, and the final write-up in a single auditable session. It's a free, MIT-licensed, local-first workbench for macOS, Windows, and Linux, positioned as the open alternative to hosted AI research products. You bring your own model keys; the app is model-agnostic and talks through a bundled OpenCode runtime. Everything an agent produces (figures, notebooks, run records) traces back to the exact code and conversation that made it, and runs can target your machine, SSH or Slurm clusters, or Modal. A token-gated gateway can serve the full UI to a browser or your phone. Researchers and grad students doing computational work are the obvious fit. Sessions, data, and provenance stay in local folders, which matters when your data can't leave the building. The catch: it's early, version 0.3 early. An agent that drives your real Chrome profile and submits jobs to your cluster is powerful, and exactly the kind of power you should think twice about handing to a young codebase.

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.

RealReplicaBench1.3k★

RealReplicaBench measures whether AI agents can finish long-horizon business workflows: 107 tasks across browser work, CLI tools, APIs, and document production, run against 14 Dockerized replicas of real SaaS systems so every run is deterministic and repeatable. The harness is Apache 2.0, the task data CC BY 4.0, free to run. Running it is heavy in the way benchmarks are: Python 3.11, Docker, pinned runtime images, and API keys for every model you evaluate. The real cost is inference spend, since 107 long-horizon tasks across model families burns serious tokens. This is an instrument for agent-framework developers and evaluation teams, not something anyone deploys. OSWorld, WebArena, and tau-bench are the peer benchmarks; SWE-bench is the coding-side equivalent. The catch: it's published by Accio, Alibaba International's commercial agent product, and Accio's own harness competes on the leaderboard while not shipping in the repo, so those results can't be independently reproduced. The mock-service design is also both the feature and the limit: scores measure competence against Accio's model of these systems, not production reality.

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.