DEV Community: Muhammad Tayyab

OpenMontage: Turn Your AI Coding Assistant Into a Full Video Production Studio

Muhammad Tayyab — Fri, 06 Nov 2026 07:43:57 +0000

OpenMontage turns your AI coding assistant into a full video production studio. Paste a Short you love and it studies the pacing, pitches concepts with the cost upfront, then writes, generates, and edits the whole video. It has 76,864 stars and gained 3,700 in the last week.

What Is OpenMontage?

OpenMontage bills itself as the first open-source, agentic video production system, and its pitch is disarmingly simple: describe what you want in plain language, and your AI coding assistant handles the research, scripting, asset generation, editing, and final composition. It is built to be driven by an agent, not clicked through in an editor, so it works with Claude Code, Cursor, Copilot, Windsurf, and Codex, any coding assistant that can read files and run code.

Under the hood it is a serious system: more than ten production pipelines, over 100 tools, and more than 700 agent skill and production-knowledge files. That depth is what lets it go from a one-line prompt to a finished video instead of stopping at a script or a storyboard. It is a Python project, licensed under AGPL-3.0, and the repository had 76,864 stars and 10,197 forks when we checked on November 5, 2026, after gaining 3,700 stars in a single week.

Start From a Video You Love

The fastest way in is also the most interesting feature: paste a reference video and let the agent study it. Give it a YouTube Short, a Reel, a TikTok, or a local clip and say something like, here is a Short I love, make me something like this but about quantum computing. The agent analyzes the transcript, pacing, scenes, keyframes, and style, then comes back with two or three differentiated concepts, an honest tool path, cost estimates, and a sample before full production starts.

What you get back is not a vague prompt. You get what it keeps from the reference, the pacing, hook style, structure, and tone; what it changes, the topic, visual treatment, angle, and narration approach; what it will cost at your target duration before any asset generation begins; and what it will actually look like with the tools you currently have available. That cost-upfront answer is the part most AI video tools skip, and it is the difference between an experiment and a plan. Decide the format before you ask: a Short or Reel is vertical 9:16 and a standard YouTube video is 16:9, and the aspect ratio calculator gives the exact pixel dimensions for either if you are reframing your own clips to match.

What It Can Actually Make

The showreel is genuinely varied, which is the point: a cinematic sci-fi trailer produced end to end, a 60-second Pixar-style animated short about a lonely banana that cost 1.33 dollars to generate, a 54-second music-driven 3D showcase with gravity-shifting furniture and frozen car drifts, a 50-second vertical transformation film, a 60-second product film, and a 100-second documentary about salt that mixes real-world footage with narration and hand-authored motion graphics.

One distinction matters more than the rest. OpenMontage can make image-based videos, but it can also make actual motion video for free and open-source workflows: the agent builds a corpus from free stock footage and open archives, retrieves actual motion clips, edits them into a timeline, and renders a finished piece. That is not the usual trick of animating a handful of stills and calling it video. If you want that path, ask for a documentary montage, tone poem, or stock-footage collage and say explicitly to use real footage only.

The Cost Question, Answered Honestly

Here is the part to understand before you start: the AI-generated clips use paid providers, so a video built on generated footage costs real money, while a video built on free stock footage costs nothing but time. OpenMontage is upfront about this at proposal time, showing you the cost before generation starts, and you choose the path yourself. The README's own examples put numbers on it: a 60-second animated short cost 1.33 dollars, a transformation film about 4 dollars, and a seven-world showcase about 5 dollars in generation costs.

The paid path runs through providers like fal.ai for FLUX images and Veo, Kling, and MiniMax video, plus ElevenLabs, OpenAI, Google, Runway, and HeyGen, each behind an API key you add to a .env file. The free path uses Piper TTS for narration, Archive.org, NASA, and Wikimedia Commons for footage, Pexels, Unsplash, and Pixabay for stock, and Remotion or HyperFrames for composition, all with no paid key at all. If you have a GPU, you can also unlock free local video generation with models like Wan 2.2. Every provider selection is scored across seven dimensions with an auditable decision log, so you can see why the agent picked what it picked.

The Backlot: A Storyboard That Watches the Production

Chat tells you what the agent said. Backlot shows you what the production is actually doing. It is a local board that fills itself in as the pipeline runs: stages light up, the script lands as a screenplay page, scene cards shimmer while assets generate, and every provider decision and dollar spent is on the wall. When a production starts, the agent opens it for you automatically.

The storyboard is also a real approval gate. Asset generation pauses on a scene-by-scene contact sheet, takes, prompts, per-asset cost, and quality scores, so you approve the visuals before the render, not after it is too late. Creative gates hold until you answer in chat, and when a run is done you can replay the whole production from its timestamps, scrubbable end to end. It is the closest thing to sitting in an edit suite while an agent does the work.

How to Try It

You need Python 3.10 or newer, FFmpeg, Node.js 18 or newer, and an AI coding assistant. Clone the repository, run make setup, open the project in your assistant, and tell it what you want in plain language, for example, make a 60-second animated explainer about how neural networks learn. If you write the narration yourself, keep in mind that 60 seconds holds only about 130 words at a typical speaking pace, and the speaking-time estimate in the Word Counter tells you whether your script fits. Or ask for the real-footage path: make a 75-second documentary montage about city life in the rain, use real footage only, no narration, elegiac tone, with music.

That is genuinely it for a first video. The agent researches your topic with live web search, generates AI images, writes and narrates the script with voice direction, finds royalty-free background music automatically, burns in word-level subtitles, and renders the final video. Before you see anything, the system runs a multi-point self-review: ffprobe validation, frame sampling, audio level analysis, delivery promise verification, and subtitle checks. Add API keys only when you want the paid providers; with zero keys you still get narration, footage, composition, subtitles, and post-production for free.

What to Watch Out For

First, the license: OpenMontage is AGPL-3.0, which is stricter than MIT or Apache. If you run it as a network service or build on it, read what AGPL requires of you, because it is not a license to ignore. Second, costs are real on the paid path. The per-video numbers are small, a dollar or a few dollars, but they scale with length and the number of takes, and the approval gates exist precisely so you do not burn money on assets you have not seen.

Third, this is an agentic system, so results depend on the assistant driving it and the providers you have configured. A run with only free tools looks different from a run with Veo and Kling behind it, and the proposal step is where you find that out, before spending anything. Finally, it is a young, fast-moving project: 76,864 stars and a week of 3,700 new ones means the docs and pipelines change often, so treat the README as the current truth. What it offers today is remarkable either way: a full video production pipeline that starts from a video you love and ends with a finished piece, open source, with the cost stated upfront.

FAQs

What is OpenMontage?

OpenMontage is an open-source, agentic video production system, and its README calls it the first of its kind. It turns your AI coding assistant into a full video production studio: describe what you want in plain language and the agent handles research, scripting, asset generation, editing, and final composition. It is written in Python, licensed under AGPL-3.0, and had 76,864 stars in November 2026.

How does OpenMontage work?

You describe the video you want to your AI coding assistant, or paste a reference video like a YouTube Short and ask for something similar about your topic. The agent analyzes the reference, pitches 2-3 concepts with cost estimates upfront, then runs one of its production pipelines, more than ten in all, using 100+ tools to research, script, generate assets, edit, and render the final video.

Which AI coding assistants work with OpenMontage?

Claude Code, Cursor, Copilot, Windsurf, and Codex. Any AI coding assistant that can read files and run code can drive it, since the system is pipeline-driven rather than a point-and-click editor.

How much does it cost to make a video with OpenMontage?

It depends on the path you choose. AI-generated clips use paid providers, and the README's examples run about $1.33 for a 60-second animated short to about $5 for a multi-scene showcase. Or you can use free stock footage and open archives, which costs nothing. OpenMontage shows you the cost upfront before generation starts, so you choose.

Can I make videos with OpenMontage without any paid API keys?

Yes. With zero API keys you get Piper TTS narration, free footage from Archive.org, NASA, and Wikimedia Commons, stock from Pexels, Unsplash, and Pixabay, Remotion or HyperFrames composition, built-in subtitles, and FFmpeg post-production. A GPU unlocks free local video generation too.

What is Backlot in OpenMontage?

Backlot is a live local storyboard that shows what a production is actually doing: stages lighting up, the script as a screenplay page, scene cards while assets generate, and every provider decision and dollar spent. It also acts as an approval gate, pausing asset generation so you approve visuals before the render.

How do I install OpenMontage?

You need Python 3.10+, FFmpeg, Node.js 18+, and an AI coding assistant. Clone the repository, run make setup, open it in your assistant, and describe the video you want. API keys for paid providers go in a .env file and are all optional.

Is OpenMontage free?

The software is free and open source under AGPL-3.0. Generating video with paid AI providers costs money per clip, but the free stock-footage path costs nothing, and OpenMontage tells you the cost before it generates anything.

Originally published at devpik.com/open-source/openmontage. Repo: calesthio/OpenMontage.

VibeVoice: Turn an Hour of Audio Into a Full Transcript in One Go

Muhammad Tayyab — Fri, 06 Nov 2026 07:42:18 +0000

VibeVoice is Microsoft's open-source voice AI that takes an hour of audio, a podcast, a meeting, a lecture, and turns it into a full structured transcript in one go. It tells you who said what and when, works in over 50 languages, and the repository has 55,376 stars.

What Is VibeVoice?

VibeVoice is a family of open-source voice AI models from Microsoft, and the one most people will reach for is VibeVoice-ASR, a speech recognition model built for long audio. Feed it up to 60 minutes of continuous audio and it produces a structured transcript in a single pass: who spoke, when they spoke, and what they said. No chopping the recording into 30-second pieces first, no stitching transcripts back together afterwards.

That single-pass design is the whole point. Most speech-to-text tools slice long recordings into short chunks, and every cut is a chance to lose track of who is speaking or what the conversation was about. VibeVoice-ASR accepts the full hour inside a 64K token window, so speaker tracking and context stay consistent from the first minute to the last. It is a Python project, licensed under MIT, and the repository had 55,376 stars and 6,241 forks when we checked on November 5, 2026.

The 60-Minute Transcript

The headline feature is simple to describe and hard to do well: one hour of audio, one pass, one transcript. A 60-minute podcast episode, a team meeting, a lecture, or an interview goes in whole, and what comes out is a structured document rather than a wall of undifferentiated text. Every line carries a speaker label and a timestamp, so you can search for the moment a specific person said a specific thing instead of scrubbing through an hour of audio. An hour of conversation runs to roughly 8,000 words, and pasting the transcript into the Word Counter gives you its length and reading time before you decide how to summarize it.

Under the hood, the VibeVoice family uses continuous speech tokenizers, acoustic and semantic, running at an ultra-low frame rate of 7.5 Hz, which keeps long sequences computationally manageable without throwing away audio fidelity, and the ASR model takes the full hour inside a single 64K token window. The practical result is that long recordings stay coherent: the transcript at minute 55 still knows who everyone is and what they were talking about at minute 5.

Who Said What, and When

A transcript is only useful if you can trust its structure, and VibeVoice-ASR does three jobs at once: speech recognition, speaker diarization, and timestamping. The output answers the three questions that matter for anyone working with recorded speech: Who, When, and What. That combination is what makes it genuinely useful for meeting notes, podcast show notes, research interviews, and lecture summaries, where knowing which person said something is as important as the words themselves.

You can also feed it customized hotwords, names, technical terms, or background context, to guide recognition. If your recording is full of product names, people's names, or domain jargon that generic models always mishear, hotwords give the model a nudge in the right direction and noticeably improve accuracy on the words that matter most to you.

Over 50 Languages

VibeVoice-ASR is natively multilingual, supporting over 50 languages out of the box. That matters because most transcription tools are tuned for English first and treat everything else as an afterthought. Here the multilingual support is a core design feature, not a checkbox, and the project documents its language coverage in the ASR docs.

There is also a streaming variant, VibeVoice-ASR-Streaming, that transcribes while the audio is still arriving, emitting text once per audio chunk instead of waiting for the recording to end. That makes it usable for live captioning and real-time meeting notes, not just post-processing. And if you want to run it on modest hardware, there is VibeVoice-ASR-BitNet, an edge CPU inference engine that compresses the model from 4.62 GB to 1.58 GB and runs in real time on three or more CPU threads, no GPU required.

A Real-Time Voice Model Too

Transcription is only half the family. VibeVoice-Realtime-0.5B is a lightweight real-time text-to-speech model that streams text in and speaks it out, with around 300 milliseconds to the first audible sound. It is a small 0.5B parameter model, which makes it deployment-friendly, and it handles robust long-form speech generation of around 10 minutes.

The Realtime model also ships with experimental voices, including multilingual voices in nine languages and eleven distinct English style voices, so you can try different tones without retraining anything. You can try it in a Colab notebook straight from the repository, which is the fastest way to hear what it sounds like before you install anything.

The voice side is small for a reason. VibeVoice originally shipped a larger text-to-speech model, and in September 2025 Microsoft removed the VibeVoice-TTS code from the repository after finding it used in ways inconsistent with its stated intent. The README is direct about the risk that remains: convincing synthetic speech can be used for impersonation, fraud and disinformation, so disclose AI-generated audio whenever you share it.

How to Try It

The fastest way in is the ASR Playground linked from the repository, which lets you test transcription without installing anything. If you want to run it yourself, the models are on Hugging Face, including the 7B ASR model, the streaming variant, and the BitNet CPU version, and the ASR model is also available directly through the Hugging Face Transformers library. VibeVoice-ASR is integrated into Azure AI Foundry Labs as well, if you prefer to explore it there.

Developers get more: vLLM inference is supported for faster serving, the finetuning code is open, and there is a full technique report for anyone who wants to understand how the model works. Start with a recording you already have, a podcast episode or a meeting you recorded, run it through the Playground or the model, and check whether the speaker labels survive a full hour. That is the test that separates this from chunk-and-stitch tools.

What to Watch Out For

VibeVoice is a research framework from Microsoft, and the project is upfront about that: it is intended for research and development, and the team does not recommend using it in commercial or real-world applications without further testing. Transcription can still be wrong, biased, or inaccurate, and the model inherits the limits of its base model, so check important transcripts rather than trusting them blindly. If you have the script or notes the speakers worked from, a text diff against the transcript shows exactly which words the model got wrong.

The other thing to know is that the project is actively evolving. New variants land regularly, a streaming model in September 2026, the BitNet CPU engine in July 2026, and the model list in the repository is the current truth, so check the README before assuming a particular model or demo is still there. What is available today is a genuinely strong open-source transcriber for long audio, free under MIT, and at 55,376 stars it is clearly the tool a lot of people reach for when an hour of audio needs to become text.

FAQs

What is VibeVoice?

VibeVoice is Microsoft's family of open-source voice AI models. The main one is VibeVoice-ASR, a speech recognition model that transcribes up to 60 minutes of audio in a single pass, producing a structured transcript with speaker labels and timestamps. It is written in Python, licensed under MIT, and had 55,376 stars in November 2026.

How long an audio file can VibeVoice transcribe at once?

Up to 60 minutes of continuous audio in a single pass, inside a 64K token window. Unlike tools that slice recordings into short chunks, it keeps the whole hour in context, so speaker tracking and coherence hold from start to finish.

Does VibeVoice tell you who said what?

Yes. It jointly performs speech recognition, speaker diarization, and timestamping, so the output shows who spoke, when they spoke, and what they said. You can also add customized hotwords for names and technical terms to improve accuracy.

How many languages does VibeVoice support?

Over 50 languages natively. The ASR documentation lists the full language coverage, and there is also a streaming variant that transcribes live as audio arrives.

Can I run VibeVoice without a GPU?

Yes, with VibeVoice-ASR-BitNet, an edge CPU inference engine that compresses the model from 4.62 GB to 1.58 GB and runs in real time on three or more CPU threads, with no GPU required.

Does VibeVoice include a real-time voice model?

Yes. VibeVoice-Realtime-0.5B is a lightweight text-to-speech model with around 300 milliseconds to first audio, streaming text input, and long-form speech generation of about 10 minutes. It includes experimental multilingual and style voices.

How do I try VibeVoice?

Start with the ASR Playground linked from the GitHub repository, or grab the models from Hugging Face. The ASR model also works through the Hugging Face Transformers library and is integrated into Azure AI Foundry Labs. vLLM inference and finetuning code are available for developers.

Is VibeVoice free?

Yes. It is free and open source under the MIT license. Microsoft notes it is a research framework intended for research and development, so test it thoroughly before using it in production.

Originally published at devpik.com/open-source/vibevoice. Repo: microsoft/VibeVoice.

T3 Code: Control All Your AI Coding Agents From Your Phone

Muhammad Tayyab — Fri, 06 Nov 2026 07:40:23 +0000

T3 Code lets you control the AI coding agents on your machine from your phone. It works with Claude Code, Codex, Cursor, OpenCode and more, uses the subscriptions you already pay for, and it had 45,475 stars when we checked.

What Is T3 Code?

T3 Code calls itself an "agent harness control surface", which is a grand way of saying one thing: it is the remote control for the AI coding agents running on your machine. You open an app on your iPhone, your Android phone, the web or a desktop app, and you drive the agents that are already set up on your computer, from wherever you are.

It works with the subscriptions you already have. Claude Code, Codex, Cursor, Grok Build, OpenCode, Google Antigravity and fx are all supported, and if a provider is installed and authenticated on your machine, T3 Code can control it. There is no new subscription to buy and no new model to pay for. The README asks the question itself, "Wait, what are you selling me?", and answers it in one word: "Nothing."

The project is written in TypeScript, licensed under MIT, and it had 45,475 stars when we checked on November 4, 2026, after gaining roughly 12,500 stars in the past week. The team says they built it because they wanted the best possible development experience with agents, inspired by the Codex desktop app, Conductor, Claude Desktop and Cursor Glass, but none of those met their bar for something performant, remote-ready and truly open. If the project ever goes the wrong direction, they want you to have everything you need to fork it and build the editor you want.

One App for Every Agent You Already Pay For

The practical appeal is consolidation. If you use Claude Code for one project, Codex for another and Cursor somewhere else, each normally has its own interface and its own way of being driven. T3 Code puts them behind one control surface, so you check on runs, steer agents and keep working from your phone instead of being chained to the machine the agents run on.

Setup follows the provider, not T3 Code. Install and authenticate at least one provider before use: Codex with the Codex CLI and codex login, Claude with Claude Code and claude auth login, Cursor with the Cursor CLI and agent login, Grok Build with grok login, OpenCode with opencode auth login, and fx with fx login on the machine running the T3 Code server. Antigravity is the exception: enable it in Settings, then use Install Antigravity and Sign in with Google, with no CLI required.

There is also a docs folder in the repository covering the details that matter once you are running: permission modes, keyboard shortcuts, project settings, appearance preferences, remote access from a phone or another machine, connecting agents over MCP, source control integrations, multiple accounts per provider, and running T3 Code as a background service. There is no docs site yet, so the repository docs are the documentation.

Install It in One Command

The fastest route is the install script, then the t3 command to start the server and open the local web app:

curl -fsSL https://t3.codes/install.sh | sh

On Windows, the PowerShell equivalent is irm https://t3.codes/install.ps1 | iex. Once installed, t3 service install keeps the server running in the background, t3 update moves to a newer release, and t3 --help has the full reference. To try it once without installing anything, run npx t3@latest instead.

Prefer a desktop app? The latest release is on GitHub Releases, and the package managers are covered: winget install T3Tools.T3Code on Windows, scoop install extras/t3code, brew install --cask t3-code on macOS, a .deb for Debian and Ubuntu, t3code-bin or t3code-nightly-bin from the AUR on Arch, and a nixpkgs package that includes both the desktop app and the t3 command. The mobile apps are on the App Store and Google Play, and the web app lives at app.t3.codes.

What to Watch Out For

The README is blunt about the project's age, and you should take it seriously: "We are very very early in this project. Expect bugs." A control surface for your coding agents sits in a privileged position, so running an early project here deserves more caution than installing a text tool. Keep it on a machine you can afford to babysit, and read the permission modes doc before you hand an agent a long leash. Supervising from a phone also makes it easy to approve work you have only skimmed, so read the actual changes at a desk before you merge: a text diff shows every line an agent rewrote, and the AI Code Detector flags the placeholder scaffolding and debug leftovers agents tend to leave behind.

Contributions are mostly closed for now. The team says small fixes may be considered, but big features will not be, so if you adopt T3 Code hoping to shape its roadmap, expect to wait. Building from source is also a heavier lift than usual: it uses Vite+ and needs the global vp command-line tool, with full instructions in the repository's contributing guide.

None of that cancels the core idea. If you already pay for two or three agent subscriptions and you want to supervise them away from your desk, a single open source remote control with no subscription of its own is a genuinely useful shape. Just go in knowing it is early, and let the phone app earn your trust before you give it the keys to anything important.

FAQs

What is T3 Code?

An open source control surface for the AI coding agents on your machine. It lets you drive those agents from an iPhone, Android phone, web app or desktop app, instead of sitting at the machine they run on.

Which coding agents does T3 Code work with?

Claude Code, Codex, Cursor, Grok Build, OpenCode, Google Antigravity and fx. Each provider must already be installed and authenticated on your machine before T3 Code can control it.

Do I need a new subscription for T3 Code?

No. T3 Code works with the subscriptions you already have for Claude Code, Codex, Cursor and the rest. The README's own answer to what they are selling is: nothing. It is MIT licensed open source.

How do I install T3 Code?

Run curl -fsSL https://t3.codes/install.sh | sh, then run t3 to start the server and open the local web app. Windows uses a PowerShell installer, desktop apps are on GitHub Releases and the major package managers, and npx t3@latest tries it once without installing.

Can I really control agents from my phone?

Yes, that is the point of the project. The iOS and Android apps, plus the web app at app.t3.codes, connect to the T3 Code server on your machine so you can supervise and steer agents remotely.

Is T3 Code stable?

Not yet, by the team's own account. The README says the project is very early and to expect bugs, and contributions are mostly not being accepted yet beyond small fixes.

Originally published at devpik.com/open-source/t3code. Repo: pingdotgg/t3code.

Karpathy Skills: One File That Makes Your AI Coding Agent Write Better Code

Muhammad Tayyab — Fri, 06 Nov 2026 07:38:50 +0000

One file that makes your AI coding agent write better code. It is based on Andrej Karpathy's complaints about AI coding, it has four rules, and it had 229,304 stars when we checked. It is inspired by Karpathy's observations, not made by him.

What Is It, and Who Actually Made It?

This is one file: a CLAUDE.md that improves Claude Code behavior, derived from Andrej Karpathy's observations on LLM coding pitfalls. Drop it into a project and the agent working in that project picks up a set of working rules. Nothing to build, nothing to configure, no service to sign up for. It had 229,304 stars when we checked on November 4, 2026, which makes it one of the most starred repositories on GitHub.

Get one thing straight first, because the name invites confusion: Andrej Karpathy did not make this. The repository is by multica-ai, and it is built from a post in which Karpathy described what frustrates him about AI coding. The file turns his observations into instructions an agent can follow. Credit the observations to Karpathy, and the file itself to the people who wrote it.

Why does a single text file get 229,000 stars? Because the problem it addresses is the one every developer hits within a week of using a coding agent: the agent does something plausible, fast, and slightly wrong, and you only discover it in review. These guidelines attack that failure mode directly instead of adding another tool on top of it.

The Three Complaints

Karpathy's post names three ways coding agents go wrong, and the file is organized as the answer to all three.

First, the models make wrong assumptions on your behalf and just run along with them without checking. They do not manage their confusion, do not seek clarifications, do not surface inconsistencies, do not present tradeoffs, and do not push back when they should. You ask for something slightly ambiguous and get a confident implementation of the wrong interpretation.

Second, they overcomplicate code and APIs, bloat abstractions, and do not clean up dead code. The README's version of this complaint is vivid: the agent implements a bloated construction over 1,000 lines when 100 would do. Third, they still sometimes change or remove comments and code they do not sufficiently understand as side effects, even when those lines are orthogonal to the task. A fix to one function quietly edits three others.

The Four Rules

The file answers the three complaints with four principles, each stated as a rule the agent must follow.

Think Before Coding means do not assume, do not hide confusion, and surface tradeoffs. State assumptions explicitly, present multiple interpretations when ambiguity exists, push back when a simpler approach exists, and stop and ask when confused instead of guessing.

Simplicity First means the minimum code that solves the problem, nothing speculative. No features beyond what was asked, no abstractions for single-use code, no flexibility or configurability that was not requested, no error handling for impossible scenarios. The test the file gives is a good one: would a senior engineer say this is overcomplicated? If yes, simplify.

Surgical Changes means touch only what you must, and clean up only your own mess. Do not improve adjacent code, comments or formatting, do not refactor things that are not broken, and match existing style even if you would do it differently. If your changes orphan imports or variables, remove those. Do not remove pre-existing dead code unless asked. The test: every changed line should trace directly to the user's request.

Goal-Driven Execution means define success criteria and loop until verified. Turn "add validation" into "write tests for invalid inputs, then make them pass", and "fix the bug" into "write a test that reproduces it, then make it pass". Karpathy's own line behind this rule is that LLMs are exceptionally good at looping until they meet specific goals, so do not tell the agent what to do, give it success criteria and watch it go.

How to Install It

For a single project, the file itself is the install. Add the repository's CLAUDE.md to your project root and Claude Code picks it up as project instructions. For an existing project, append it to your current CLAUDE.md instead of replacing the project-specific guidance you already have. The guidelines are designed to merge with project-specific instructions, and the README shows how to add a project-specific section on top, for example TypeScript strict mode or API test requirements. If you merge it into a long existing CLAUDE.md, paste the result into a Markdown converter to check that the headings still render as separate sections instead of running together.

There is also a Claude Code plugin route documented in the README, which makes the skill available across all your projects rather than one at a time, and a committed Cursor project rule, so the same guidelines apply when you open the project in Cursor. If you use both Claude Code and Cursor, the Cursor setup is worth doing: the same four rules then govern the agent whichever editor you are in.

You will know it is working when diffs get smaller and cleaner: fewer unnecessary changes, fewer rewrites due to overcomplication, clarifying questions before implementation instead of after mistakes, and minimal pull requests with no drive-by refactoring. That is the outcome the file is optimizing for, and it is measurable in your very next review. The simplest test is to give the agent the same task with and without the file, then compare the two results in a text diff.

What to Watch Out For

The guidelines bias toward caution over speed, and the README says so openly. For trivial tasks, simple typo fixes and obvious one-liners, use judgment: not every change needs the full rigor. Applying all four rules to a one-line fix is the kind of over-engineering the second rule is trying to kill.

The second watch-out is the name. Because the repository is called andrej-karpathy-skills and the star count is enormous, it is easy to repeat the claim that Karpathy built it. He did not. Saying so in a post or a video is the kind of small inaccuracy that undermines an otherwise good recommendation, so keep the attribution exactly as the repository states it: derived from Karpathy's observations.

Finally, remember what this is and is not. It is a text file of instructions, not a model, not a plugin with behavior of its own, and not a guarantee. An agent can still ignore instructions, and the rules work best when you also review the diff. What the file buys you is a much better default: an agent that asks before assuming, writes less code, touches only what you asked for, and proves its work with tests.

FAQs

Did Andrej Karpathy make this?

No. The repository is by multica-ai and is derived from Karpathy's public observations on LLM coding pitfalls. It is inspired by Karpathy's complaints, not made by him.

What are the four rules?

Think Before Coding (state assumptions, ask when confused), Simplicity First (minimum code that solves the problem), Surgical Changes (touch only what you must, clean up only your own mess), and Goal-Driven Execution (define success criteria and loop until tests verify them).

How do I install it?

Add the repository's CLAUDE.md file to your project root, or append it to your existing CLAUDE.md. A Claude Code plugin route covers all your projects at once, and a committed Cursor rule applies the same guidelines in Cursor.

What problems does it actually fix?

The three complaints in Karpathy's post: agents making wrong assumptions without checking, overcomplicating code and bloating abstractions, and editing comments or code they do not understand as side effects of a task.

Will it slow my agent down?

Slightly, by design: the guidelines bias toward caution over speed. For trivial tasks like typo fixes, the README says to use judgment rather than applying the full rigor.

Is it really just one file?

Yes. The core is a single CLAUDE.md file of guidelines, MIT licensed, with a Cursor rule file alongside it. There is nothing to build and no service involved.

Originally published at devpik.com/open-source/andrej-karpathy-skills. Repo: multica-ai/andrej-karpathy-skills.

claude-mem: Give Your Coding Agent a Memory That Survives the Session

Muhammad Tayyab — Fri, 06 Nov 2026 07:37:11 +0000

Coding agents forget everything when the session ends. claude-mem fixes that by recording what the agent does, summarizing it, and feeding the relevant context back the next time you start. It works with Claude Code, Codex, OpenCode, Gemini and more, and it had 111,386 stars when we checked.

What Is claude-mem?

claude-mem is a persistent memory system for coding agents, built for Claude Code and extended to other harnesses. It automatically captures tool usage observations during a session, generates semantic summaries of what happened, and makes them available to future sessions, so the agent keeps continuity of knowledge about your projects even after a session ends or reconnects.

It comes from Alex Newman (@thedotmack), is written in TypeScript, and is licensed under Apache 2.0. The repository was created on August 31, 2025, and when we checked on November 3, 2026 it had 111,386 stars and 9,706 forks, with a version 15.9.0 badge on the README and translations into more than thirty languages. That scale makes it one of the most starred developer tools on GitHub, and it is trending again today.

The pitch is simple: the most annoying thing about AI coding agents is that they forget everything when the session ends. You re-explain decisions, re-find bugfixes, and re-teach conventions every time you start over. claude-mem records what the agent does, summarizes it, and feeds it into the next session automatically, so the next session starts where the last one ended.

How It Works: Hooks, Worker, Database

The system has six core components. Lifecycle hooks fire at SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop and SessionEnd, each as one shell-free command, claude-mem hook claude-code <event>, run by a small launcher the installer puts on PATH. A smart install step checks cached dependencies, and a worker service provides a local HTTP API with a web viewer UI and search endpoints, managed by Bun.

Underneath, a SQLite database stores sessions, observations and summaries, with FTS5 full-text search, and a Chroma vector database adds hybrid semantic plus keyword search for intelligent retrieval. A mem-search skill ties it together: the agent queries its own project history in natural language instead of relying on whatever fits in the current context window.

Two more pieces round it out. A local My Work view shows live requests, progress, human handoffs and a saved review queue at the worker URL printed on startup, with memory, sessions and settings at /viewer. TeamBrain is an optional shared workspace beside it, with real team work lists and member attribution, where each person chooses what to share and personal requests and review notes stay separate.

Search That Saves Tokens: The 3-Layer Workflow

Memory is only useful if recalling it does not eat the context window it is meant to save. claude-mem's answer is a three-layer workflow through its MCP search tools, designed around progressive disclosure: filter cheaply first, fetch details only for what survives.

First, search returns a compact index with IDs, at roughly 50 to 100 tokens per result. Then timeline gives chronological context around the interesting results, so the agent sees what was happening around a decision rather than a single isolated note. Finally, get_observations fetches full details only for the filtered IDs, at roughly 500 to 1,000 tokens per result. The README claims about 10x token savings from filtering before fetching, and the shape of the workflow makes the claim easy to believe: most results never reach the expensive layer.

Search supports full-text queries with filters by type, date and project, and observation types include decisions, bugfixes, security alerts and other needles worth finding later. Citations work through observation IDs, viewable in the web viewer or through the worker API.

Install It in One Command

The recommended install is a single command, and the installer sets everything up before asking anything of you:

npx claude-mem install

After setup it asks you to sign in to claude-mem in your browser with an email magic link, no card required. Signing in provisions a memory key and unlocks the claude-mem observer with a 30 day free trial, during which memory runs off-plan, so you get up to 100 percent more usage from your plan. When the trial ends, memory automatically falls back to your Anthropic plan unless you subscribe.

Prefer to skip the sign-in? Pass an explicit --provider flag, set CLAUDE_MEM_ONLINE_OPTIN=false, or run in CI or a non-interactive shell, and the installer completes without any account interaction. You can pick the claude-mem observer, your own OpenRouter or Gemini key, or your Anthropic plan as the memory provider.

One trap to avoid: claude-mem is also published on npm, but npm install -g claude-mem installs the SDK and library only. It does not register the plugin hooks or set up the worker service, so always install via npx claude-mem install or the plugin marketplace commands. Inside Claude Code that is /plugin marketplace add thedotmack/claude-mem followed by /plugin install claude-mem, then a restart.

Beyond Claude Code: OpenCode, Codex, Gemini and More

Although it started with Claude Code, claude-mem now covers a wide bench of harnesses. OpenCode works from version 1.3.4 onward, including OpenCode 2, with npx claude-mem install --ide opencode and a restart. T3 Code, which manages Codex and Claude Code providers, gets native plugins through --ide t3code. Antigravity CLI, Oh My Pi, Pi and DeepSeek Harness all have their own install flags or guides, and OpenClaw gateways get a one-line curl installer that handles dependencies, plugin setup, provider configuration, worker startup and optional real-time observation feeds to Telegram, Discord and Slack.

Grok Bot is a special case worth knowing about: it has no host hooks, so claude-mem watches its chat log files instead, and an awareness push pilot appends dated needle observations into that bot's memory log. If you use several harnesses, one setting matters: CLAUDE_MEM_SESSION_START_INCLUDE_ALL_SOURCES in the settings file includes observations from every harness in Claude Code and Codex session-start context. The default is false, which limits startup context to the current harness.

Workflow modes add another layer. The CLAUDE_MEM_MODE setting controls both behavior and the language of generated observations, with modes such as code, code--zh and code--ja defined in the plugin's modes directory. Restart Claude Code after changing it.

Privacy and Control

A tool that records everything your agent does has to answer the privacy question first, and claude-mem gives you real controls rather than a promise. Wrap content in <private> tags to exclude it from storage entirely. Screenshots are opt-in and off by default: when enabled, converted copies are kept under ~/.claude-mem/media-v1/, uploaded to cmem.ai only when Cloud Sync is on, and sent to the observer model only when image inference is separately enabled.

Settings live in ~/.claude-mem/settings.json, auto-created with defaults on first run, covering the AI model, worker port, data directory, log level and context injection settings. Cloud Sync backs memories up to cmem.ai with no daemon, since the worker syncs on write. The viewer settings also expose the include-all-sources toggle, so you can change recall behavior without editing JSON.

System requirements are modest but specific: Node.js 20 or higher, a recent Claude Code with plugin support, Bun as the runtime and process manager, uv for vector search, and SQLite 3, with Bun and uv auto-installed if missing. On Windows, the installer places a launcher at %LOCALAPPDATA%\claude-mem\bin\claude-mem.exe and adds it to your user Path; restart your terminal or IDE afterwards, and run npx claude-mem doctor if hooks report the executable as missing.

What to Watch Out For

The free trial is the first thing to calendar. After 30 days, memory falls back to your Anthropic plan unless you subscribe, so a workflow built on off-plan memory quietly gets thinner if you do nothing. The README is upfront about this, but it is easy to miss in the excitement of the first week.

The second watch-out is provider choice. The default path signs you into a hosted observer, which means your agent's observations pass through a third-party service. If that bothers you, the local observer and bring-your-own-key options exist, but they are opt-in, not the default, so choose deliberately at install time rather than accepting the default flow.

Finally, one naming trap: CMEM is a token created by a third party but officially embraced by claude-mem's creator as a community catalyst. It is not the tool, not a licence, and not required to use it, so do not confuse buying or holding it with using claude-mem. The tool itself is Apache 2.0 open source, and its docs live at docs.claude-mem.ai with installation, usage, search, architecture and troubleshooting guides.

FAQs

What is claude-mem?

A persistent memory system for coding agents, built for Claude Code, that captures tool usage observations, generates semantic summaries, and injects relevant context into future sessions. It had 111,386 stars in November 2026 and is licensed under Apache 2.0.

Which coding agents does claude-mem work with?

Claude Code first, plus OpenCode, Codex, Gemini, Hermes, Copilot, OpenClaw, T3 Code, Antigravity CLI, Oh My Pi, Pi and DeepSeek Harness, each with its own install flag or guide.

Do I need an account to use claude-mem?

No. The default installer asks for an email magic-link sign-in to unlock the hosted observer's 30 day free trial, but passing --provider, setting CLAUDE_MEM_ONLINE_OPTIN=false, or running non-interactively completes the install without any account interaction.

What does claude-mem cost after the free trial?

When the 30 day observer trial ends, memory automatically falls back to your Anthropic plan unless you subscribe. Memory running off-plan during the trial gives up to 100 percent more usage from your plan.

Where is my claude-mem data stored?

Locally in a SQLite database plus a Chroma vector database, with a local worker service and web viewer. Cloud Sync to cmem.ai is available as a backup, and the worker syncs on write with no separate daemon.

Can I keep sensitive content out of claude-mem's memory?

Yes. Wrap content in tags to exclude it from storage. Screenshots are opt-in and off by default, and are only uploaded or sent to the observer model when you separately enable Cloud Sync or image inference.

How does claude-mem save tokens when recalling memory?

Through a three-layer workflow: search returns a compact index at roughly 50 to 100 tokens per result, timeline adds chronological context, and get_observations fetches full details only for filtered IDs at roughly 500 to 1,000 tokens each, for about 10x savings versus fetching everything.

Does claude-mem work on Windows?

Yes. The installer places a launcher in %LOCALAPPDATA%\claude-mem\bin and adds it to your user Path; restart your terminal or IDE afterwards, and run npx claude-mem doctor if hooks report the executable as missing.

Originally published at devpik.com/open-source/claude-mem. Repo: thedotmack/claude-mem.

agent-desktop: Let AI Agents Use Your Computer's Apps, Without Screenshots

Muhammad Tayyab — Fri, 06 Nov 2026 07:35:23 +0000

agent-desktop lets an AI agent see a desktop app the way a screen reader does: every button and text field as a structured element with a ref it can click or type into. No screenshots, no pixel guessing, and the loop stays inside your agent. Here is how it works, what it can do, and where it still falls short.

What Is agent-desktop?

agent-desktop is a computer-use CLI and C library from Vercel Labs that lets AI agents read and operate desktop apps through the operating system's accessibility tree. Instead of taking a screenshot and guessing where the buttons are, the agent gets a structured snapshot: every element it can act on, with a role, a name, and a ref it can click, type into, or scroll. The agent acts on a ref, takes a new snapshot, and checks that the action worked, with no pixel matching anywhere in the loop.

It runs on macOS, Windows and Linux, is written in Rust, and is licensed under Apache 2.0. Install it from npm and it ships native binaries and platform helpers for x64 and ARM64. When we checked on November 3, 2026 it had 11,728 stars and 796 forks, and the repository notes it gained about 3,800 stars in a single day, making it the day's fastest-growing repo.

The design keeps the loop inside your agent. Every CLI call runs in its own process, and the agent's own code decides what to do next, which means agent-desktop works with any harness rather than locking you into one vendor's agent. By default it is headless: ref actions go through the accessibility API without moving the pointer or taking focus, and headless calls prohibit foreground activation and synthesized input. The global --headed flag allows physical input when you actually want it.

Snapshots and Refs: How It Sees an App

The core loop is three commands: observe, act, observe again. Any app name from agent-desktop list-apps works; Finder is the macOS example in the README. Each command prints one JSON envelope with ok and either data or error, which makes the output easy to parse in an agent loop, and pasting a snapshot into a JSON formatter makes the tree readable while you are learning the format.

agent-desktop snapshot --app Finder -i      # interactive elements, each with a ref
agent-desktop click @s8f3k2p9:e8            # act on a ref from that snapshot
agent-desktop snapshot --app Finder -i      # observe again to verify

A snapshot returns JSON with a ref for every element the agent can act on, plus the app, window, snapshot id and ref count. Refs belong to their snapshot: a bare @e8 is rejected, and when the UI changes an action returns STALE_REF or AMBIGUOUS_TARGET, which is the signal to take a fresh snapshot and use its refs. When several windows match, the snapshot lists the candidate window ids and you pass one with --window-id.

Dense apps need a map first. snapshot --skeleton --app Slack -i --compact gives the outline, then snapshot --root @s8f3k2p9:e3 -i --compact drills into one region, so the agent never has to swallow a whole application's tree in one context window.

What It Can Do: 60 Commands

The README lists 60 command names, 56 of them operational. The observe group covers snapshot, find, get, is, screenshot and list-surfaces. The act group works on refs: click, double-click, triple-click, right-click, type, set-value, clear, focus, select, toggle, check, uncheck, expand, collapse, scroll and scroll-to.

Beyond that there are keyboard and mouse commands (press, hover, drag, mouse-move, mouse-click, mouse-wheel), app and window management (launch, close-app, list-apps, list-windows, list-displays, focus-window, resize-window, move-window, minimize, maximize, restore, open-system-surface), notifications (list-notifications, dismiss-notification, dismiss-all-notifications, notification-action), clipboard (clipboard-get, clipboard-set, clipboard-clear), plus wait, session commands (session, trace, cursor-overlay) and system commands (status, permissions, version, batch, skills).

Four commands refuse to run until a daemon can release a held key or button: key-down, key-up, mouse-down and mouse-up. That is a safety rail, not a missing feature: a held key with no release path would leave the machine in a stuck state.

The Agent Loop, Built Into the Binary

agent-desktop ships its own documentation, matched to its version, so an agent never has to guess at flags or semantics. agent-desktop skills get desktop returns the loop, refs, verification and retry rules, and agent-desktop skills get platform prints what differs on the OS you are running on. Every command also has --help.

Install the skill into an agent harness from skills.sh, or add a short block to your AGENTS.md telling the agent to fetch the desktop and platform skills before its first use and follow them. The error contract is part of the same story: an error carries a code, a disposition and usually a suggestion, and you retry only when error.disposition.retry is safe. That single rule stops the classic agent failure mode of retrying an action that already partially happened.

For programs rather than CLIs, each release also ships libagent_desktop_ffi for macOS, Linux and Windows, so you can call the tool in process instead of starting the CLI for each command. agent-desktop skills get ffi covers the entry points, memory ownership and threading rules.

Platform Support and Permissions

All three platforms get the accessibility tree, click and type, screenshots, clipboard and app and window management, but the details differ. macOS needs Accessibility permission, granted through agent-desktop permissions --guide. Windows needs no grant for apps at your terminal's integrity level. Linux needs the user's graphical session with at-spi2-core.

The edges are where the README is honest. On Linux, mouse input works on X11 with --headed, screenshots use X11 windows or the Wayland portal, clipboard on Wayland needs wl-clipboard, and window control is X11 only. Notifications work on macOS, Windows and GNOME Shell. Shell surfaces such as the Dock, menu bar extras, GNOME tray and Action Center are reachable through open-system-surface.

Official Homebrew and Scoop packages are being submitted but are not yet in the default catalogs, and the repository no longer maintains a custom Homebrew tap or Scoop bucket. For direct execution without a JavaScript launcher, download the matching native archive from GitHub Releases and keep its helper beside the executable.

Privacy: What to Watch Out For

The README's privacy warning deserves to be read before you hand this to an agent. Snapshots, clipboard reads, screenshots, command output and debug artifacts can contain private desktop content, so keep them out of public logs and uploads. That is not a hypothetical: a snapshot of a mail client or a password manager is a dump of your screen in structured form.

One optional helper is separate from the native CLI and easy to confuse with it. The JEV helper sends screen descriptions to a configured model provider; it is not part of the CLI's local loop, so if you care about keeping screen content local, do not enable it without reading its docs. The privacy and data handling notes live in the repository's FAQ.

Two smaller gotchas: in PowerShell, quote every ref (a bare @token is the splatting operator), and remember that refs go stale. An agent that caches refs across snapshots will spend its budget on STALE_REF errors instead of doing work.

Try It Yourself

Install it globally with npm, which also works under Bun, Yarn and pnpm:

npm install -g agent-desktop
agent-desktop version

On macOS, run agent-desktop permissions --guide first and grant Accessibility access, then list what is running and take your first snapshot:

agent-desktop list-apps
agent-desktop snapshot --app Finder -i

Pick a ref from that snapshot, act on it, and snapshot again to verify, exactly as the quick start shows. If the action fails, read the error envelope: the code and suggestion tell you whether to retry, re-snapshot, or disambiguate a window. The repository's docs folder covers installation problems, the JSON output contract, concepts such as refs and sessions, and a solutions directory of past bugs and lessons.

FAQs

What is agent-desktop?

An open-source CLI and C library from Vercel Labs, licensed under Apache 2.0, that lets AI agents read and operate desktop apps through the OS accessibility tree. It had 11,728 stars in November 2026.

How is agent-desktop different from screenshot-based computer-use tools?

Screenshot tools guess where buttons are from pixels. agent-desktop reads the app's accessibility tree, so the agent gets every interactive element as structured data with a ref it can click or type into, then re-snapshots to verify. No pixel matching is involved.

Which operating systems does agent-desktop support?

macOS, Windows and Linux. macOS needs Accessibility permission, Windows needs no grant at the terminal's integrity level, and Linux needs the graphical session with at-spi2-core. Some features, such as Linux mouse input and window control, are X11 only.

How do refs work in agent-desktop?

Each snapshot assigns a ref to every actionable element, scoped to that snapshot, such as @s8f3k2p9:e8. Actions take a ref from the latest snapshot; if the UI changed, you get STALE_REF or AMBIGUOUS_TARGET and must take a fresh snapshot.

Does agent-desktop move my mouse or take focus?

Not by default. Ref actions go through the accessibility API without moving the pointer or taking focus, and headless calls prohibit foreground activation and synthesized input. The --headed flag allows physical input when you want it.

Can I use agent-desktop from code instead of the CLI?

Yes. Each release ships libagent_desktop_ffi for macOS, Linux and Windows, and agent-desktop skills get ffi documents the entry points, memory ownership and threading rules.

Is agent-desktop free?

Yes. It is open source under the Apache License 2.0, so there is no licence fee; the costs are your own machine and whatever agent harness you run it with.

Does agent-desktop send my screen to the cloud?

The native CLI works locally through the OS accessibility APIs. The optional JEV helper is separate and does send screen descriptions to a configured model provider, so do not enable it if you want screen content to stay local. Snapshots and clipboard reads can contain private content, so keep them out of public logs.

Originally published at devpik.com/open-source/agent-desktop. Repo: vercel-labs/agent-desktop.

nanochat: Train Your Own GPT-2 Grade ChatGPT in About Two Hours

Muhammad Tayyab — Fri, 06 Nov 2026 07:33:47 +0000

nanochat trains a ChatGPT-style model from scratch, tokenizer to chat, on a single 8XH100 node. The GPT-2 speedrun record is 1.65 hours, about 1,000 times cheaper than GPT-2 cost in 2019. Here is how it works, what a run really costs, and how to try it.

What Is nanochat?

nanochat is Andrej Karpathy's experimental harness for training a large language model from scratch, end to end, on a single GPU node. One codebase covers every stage: training the tokenizer, pretraining, supervised finetuning, evaluation and inference, ending in a chat model you can talk to from the command line. The repository's own tagline is "The best ChatGPT that $100 can buy."

The name comes from Karpathy's earlier nanoGPT, which only covered pretraining. nanochat goes the rest of the way to a chatbot and deliberately stays small. Its contributing notes promise no giant configuration objects, no model factories and no if-then-else monsters, just a single, cohesive, minimal, readable, hackable and maximally forkable strong baseline. Most of the logic sits in a handful of files, such as nanochat/gpt.py for the Transformer, nanochat/engine.py for inference with a KV cache and nanochat/optim.py for the AdamW and Muon optimizers.

It is written in Python on PyTorch, licensed under MIT, and was first published on October 13, 2025. When we checked on November 2, 2026 it had 59,646 stars and 8,388 forks. For questions, the README points to DeepWiki, the repository's Discussions tab and a #nanochat channel on Discord.

One Dial Sets the Whole Model

The design idea that makes nanochat easy to use is a single complexity dial: --depth, the number of Transformer layers. Everything else is derived from it automatically, including the width of the model, the number of attention heads, learning rate adjustments, the training horizon and weight decay, all chosen so the result comes out compute optimal. You ask for a smaller or bigger model and the rest follows.

Sweeping that one dial gives what Karpathy calls a miniseries of compute-optimal models at different sizes. GPT-2 capability currently sits between depth 24 and depth 26. For quick experiments he likes depth 12, roughly GPT-1 sized, where a pretraining run takes about five minutes: change something, rerun d12 and watch validation bits per byte, the CORE score and training throughput to see whether it helped. Odd depths such as 25 are not recommended, because the head-dimension math stops coming out neatly.

The dial is also the bar for contributions. A change has to be principled enough to work at every depth rather than being tuned to one model, which is what keeps the codebase small while it improves.

Training length has its own knob, --target-param-data-ratio, the number of training tokens per non-embedding parameter. Compute optimal is currently 10.5. The GPT-2 runs deliberately go lower and slightly undertrain a d24, because the goal there is to cross the GPT-2 line as fast as possible rather than to get the best model for the compute spent.

The Record: GPT-2 in 1.65 Hours

The main focus of development is a "time to GPT-2" speedrun, inspired by the modded-nanogpt project: the wall-clock time an 8XH100 node needs to train a model that beats GPT-2 (1.6B) on the DCLM CORE score, an ensemble of 22 evaluations such as ARC and MMLU. GPT-2's CORE score is 0.256525, and a run has to land above it.

The record has fallen quickly. The first entry, on January 29, 2026, took 3.04 hours with a slightly overtrained d24. FP8 training brought it to 2.91 hours on February 2, doubling the batch to about 1M tokens got it to 2.76 hours on February 5, and switching the pretraining data to NVIDIA ClimbMix cut it to 2.02 hours on March 4, after FineWeb, DCLM and Olmo data had all failed to help. The last two records, 1.80 hours on March 9 and 1.65 hours on March 14, 2026, came from autonomous research: improvements found by a private version of Karpathy's autoresearch on a d12 model, which carried over to d24.

The current record, 1.65 hours or 99 minutes, is the average of five runs with a mean CORE of 0.262634. Whatever holds the record is always the recipe in runs/speedrun.sh, so cloning the repository gives you the current best rather than last year's tutorial.

The Cost Math: About 1,000 Times Cheaper Than 2019

The leaderboard notes give enough numbers to check the headline claim. OpenAI trained GPT-2 in 2019 on 32 TPU v3 chips for 168 hours at about $8 per chip-hour: 32 x 168 x $8 = $43,008, the "approx. $43K" the README quotes. At the README's assumed $3 per GPU-hour, an 8XH100 node costs about $24 an hour, so the 1.65-hour record is about $39.60 of training time.

That is roughly 1,086 times cheaper and about 100 times faster in wall-clock time, and the hardware tells the same story: 5,376 TPU-hours then, 13.2 H100-hours now. Run 1's log puts its total compute at 4.330784131228946e+19 floating point operations; a scientific notation converter turns that into a plain number, about 43.3 quintillion.

The catch is that the leaderboard measures only the training iterations. Its notes say the reported time excludes evaluations and logging, while the full speedrun script also downloads data, trains a tokenizer, evaluates the base model and runs supervised finetuning. So the repository quotes three numbers for one job: about 1.5 hours in the script's header, 1.65 hours on the leaderboard, and about 2 hours, or $48, in the README's introduction. The 1.5-hour figure is already shorter than the training phase alone, so plan on the last one. The README adds that a spot instance can bring the total closer to $15.

Run the Speedrun Yourself

nanochat uses uv for dependencies. On a CUDA machine run uv sync --extra gpu, or uv sync --extra cpu for CPU-only and Apple Silicon, then activate the environment with source .venv/bin/activate. For the real thing, rent an 8XH100 node (the README mentions Lambda, which provided compute for the project), clone the repository and start the whole pipeline in one command, ideally inside screen so it survives a dropped connection:

screen -L -Logfile runs/speedrun.log -S speedrun bash runs/speedrun.sh

The script is short enough to read before you pay for the node. It downloads 8 data shards, about 2 billion characters, and trains a BPE tokenizer with a vocabulary of 32,768 on them while the download continues in the background up to 170 shards. About 150 are needed for GPT-2 capability, and at roughly 100 MB each that is around 17 GB of text to pull before pretraining starts; a unit converter helps when you are sizing the disk. Then it pretrains a d24 with FP8 and a data ratio of 8, evaluates the CORE score, and runs supervised finetuning to teach conversation tokens, tool use and multiple choice, with evaluations on tasks such as ARC, GSM8K, MMLU and a simple Python coding set.

When it finishes, chat with your model:

python -m scripts.chat_cli

Add -p "Why is the sky blue?" for a single prompt instead of an interactive session. Logging to Weights & Biases is optional: run wandb login and set WANDB_RUN before starting the script, otherwise it skips wandb entirely.

Smaller Hardware Works, Just Slower

You do not need eight H100s to use nanochat, only to match the leaderboard. The README says the code runs fine on an 8XA100 node, a bit slower. On a single GPU, drop torchrun and the code switches to gradient accumulation automatically and produces nearly identical results, but it takes eight times longer, so a run measured in hours on a node becomes most of a day.

If your GPU has less than 80 GB of memory, lower --device-batch-size from its default of 32 to 16, 8, 4, 2 or even 1 until it fits, keeping it a power of two. The training script compensates with more gradient accumulation steps, so the total batch the optimizer sees stays the same and only the number of passes changes.

Precision is set explicitly rather than through autocast. A single COMPUTE_DTYPE defaults to bfloat16 on A100, H100 and newer cards, and to float32 on older ones such as the V100 and T4, where float16 is available with NANOCHAT_DTYPE=float16 and a gradient scaler (reinforcement learning does not support it yet). CPU and Apple MPS default to float32, and recent macOS also runs bfloat16 with about 25% less memory at similar speed. The --fp8 flag is optional: without it training runs in bf16 and produces a slightly stronger model.

For a laptop, runs/runcpu.sh shrinks the model until training fits in a few tens of minutes on CPU or Apple Silicon. The README is blunt that you will not get strong results that way. It is for learning the pipeline, not for building a useful chatbot.

What to Watch Out For

Set expectations for the model itself. The speedrun trains with about 4e19 FLOPs, which the README compares to talking to a kindergartener: it writes stories and poems, explains why the sky is blue with confident nonsense, and hallucinates if you ask it who you are. That is the nature of a model this size, not a flaw in your run.

A single run is a sample, not a guarantee. When Karpathy ran the Run 4 recipe seven times, CORE scores ranged from 0.25119 to 0.26765, and three of the seven landed below GPT-2's 0.256525. Later records were set on averages with a larger safety margin, and the leaderboard notes recommend tracking validation bits per byte as a smoother signal, with the warning that it is not comparable across runs on different datasets.

Some documentation has drifted behind the code. The README's file tree still describes speedrun.sh as training "the ~$100 nanochat d20" while the script now trains a d24, and the original October 2025 announcement is marked as containing deprecated information. Non-CUDA backends such as XPU and MPS should work because the code is mostly plain PyTorch, but the README says not all of those paths have been exercised.

If you plan to contribute, read the AI policy first: pull requests must disclose any parts with substantial LLM contribution that you did not write or do not fully understand. The latest leaderboard record dates from March 14, 2026 and the last push to the repository was on September 7, 2026, so check the Discussions tab for current activity before building on it.

FAQs

What is nanochat?

Andrej Karpathy's minimal, open-source harness for training a ChatGPT-style model from scratch on one GPU node. It covers tokenizer training, pretraining, finetuning, evaluation and inference in one small PyTorch codebase, licensed under MIT, and had 59,646 stars in November 2026.

How much does it cost to train a GPT-2 grade model with nanochat?

The README puts a full run at about 2 hours on an 8XH100 node, roughly $48 at $3 per GPU-hour, and closer to $15 on a spot instance. The 1.65-hour leaderboard record counts only the training iterations, about $40 of node time. Training GPT-2 originally cost about $43,000 in 2019.

How long does the nanochat speedrun take?

The leaderboard record is 1.65 hours (99 minutes) of training, set on March 14, 2026. The full speedrun.sh pipeline also downloads data, trains the tokenizer, evaluates and finetunes, so budget about 2 hours of node time.

Can I run nanochat on a single GPU or a Mac?

Yes. On one GPU, omit torchrun and it uses gradient accumulation with nearly identical results, eight times slower; lower --device-batch-size if the GPU has less than 80 GB. runs/runcpu.sh trains a much smaller model on CPU or Apple Silicon in tens of minutes, with weak results.

What does the --depth flag do in nanochat?

It is nanochat's single complexity dial: the number of Transformer layers. Width, attention heads, learning rate, training horizon and weight decay are derived from it automatically. GPT-2 capability is around depth 24 to 26, and depth 12 suits five-minute experiments.

What is the CORE score?

An ensemble metric from the DCLM paper over 22 evaluations such as ARC and MMLU. nanochat uses it to decide whether a run beats GPT-2, whose CORE score is 0.256525.

How is nanochat different from nanoGPT?

nanoGPT, Karpathy's earlier project, covered only pretraining. nanochat goes all the way to a chat model: tokenizer, pretraining, supervised finetuning, evaluation and inference with a KV cache, plus a command-line chat to talk to the result.

Is the model nanochat trains actually useful?

As a learning tool and research baseline, yes. As an assistant, no: the README compares the speedrun model to a kindergartener that writes short stories and poems but hallucinates freely. Its value is that you trained every stage yourself and can change any of it.

Originally published at devpik.com/open-source/nanochat. Repo: karpathy/nanochat.

FreeToken: Run Frontier MoE Models on Your Own GPU, and the RAM It Takes

Muhammad Tayyab — Fri, 06 Nov 2026 07:31:58 +0000

FreeToken runs frontier-scale Mixture-of-Experts models on personal hardware by keeping experts in system RAM and caching the busy ones on the GPU. Its paper reports a 284B model on a gaming desktop. Here is how it works, how much RAM that claim implies, and how to serve your first model.

What Is FreeToken?

FreeToken is an open-source serving engine for running frontier-scale Mixture-of-Experts (MoE) language models on personal and consumer hardware. Instead of assuming a datacenter GPU with room for every weight, it treats the GPU, the CPU, system memory and the links between them as one elastic inference platform, and it exposes OpenAI and Anthropic compatible APIs so coding agents can use a local model the way they use a cloud one.

It comes from FlashML-org, and the accompanying paper, "FreeToken: Efficient Edge-Native MoE Serving with Bandwidth-Adaptive Execution," was posted to arXiv on August 17, 2026, with authors including Ion Stoica, Matei Zaharia, Song Han and Kurt Keutzer. The abstract reports more than 20 MoE models served on hardware ranging from an 8 GB laptop GPU to a single workstation GPU: a 35B model on a laptop, a 284B model on a gaming desktop, and the 753B GLM-5.2 on one workstation card.

The repository was created on July 20, 2026, is licensed under Apache 2.0, and had 15,782 stars and 1,571 forks when we checked on November 2, 2026. The project credits mini-sglang as its main inspiration and says it reuses designs and code from SGLang, vLLM, FlashInfer, flash-linear-attention, LightLLM and llama.cpp.

Why a Huge MoE Model Fits on One Consumer GPU

The trick is in how MoE models work. Each layer holds many small expert networks, but a router sends each token to only a few of them, so most weights sit idle on any given step. Qwen3.6-35B-A3B, the model FreeToken's quick start uses, has 35 billion parameters in total but only about 3 billion active per token, which is what the A3B in its name means.

FreeToken builds on that. In its default offload strategy the experts live in host RAM and the GPU keeps a least-recently-used cache of expert slots: a token whose expert is already cached runs at GPU speed, and a miss is streamed over PCIe. The cpu strategy computes misses on the CPU instead of fetching them, and hybrid splits each step's misses between the two, overlapped, using bandwidth figures you measure once per machine with ft bench bw. If the experts fit in VRAM, fused keeps them all resident. Left on auto, dense models resolve to fused and MoE models to offload, except on unified-memory machines such as DGX Spark, where copying between CPU and GPU memory would only move data between two names for the same RAM.

Around that core sit the features the README highlights: double-buffered prefill streaming, one global LRU pool of experts shared across layers, FreeToken's own FTW fast-load weight format, VRAM that can move between the expert cache and the KV cache at runtime without a restart, and semantic anchor checkpoints that let agent edits such as tool calls and thinking blocks reuse context instead of recomputing it.

The Real Requirement Is System RAM

Offloading moves the problem rather than removing it: every expert still has to live somewhere, and that somewhere is your system memory. A back-of-envelope estimate shows what the paper's headline implies. A 284-billion-parameter model stored at 4 bits per weight is about 142 GB. In NVFP4, which adds an 8-bit scale for every 16 weights, it is closer to 160 GB, before the operating system, the KV cache and anything else you run. By the same arithmetic, the 753B GLM-5.2 result implies well over 400 GB of RAM.

So the "gaming desktop" in that claim is a PC with a GPU you can buy off the shelf and around 192 GB of RAM, which is the top end of consumer builds rather than a typical one. The laptop result scales the same way: a 35B model at 4.5 bits per weight is roughly 20 GB, far more than an 8 GB laptop GPU holds, so most of it sits in system RAM and a 16 GB laptop would not fit it. These are our estimates from the parameter counts, not figures FreeToken publishes, and the real footprint depends on each checkpoint's formats.

Storage matters too. DeepSeek-V4.1-Flash's two 98 GiB Engram tables stream from the checkpoint shards on demand, and the docs recommend keeping them on a fast NVMe drive. Qwen3.8-Flash-Next keeps a 47.7 GiB n-gram table pinned in host RAM. On Windows and WSL, CUDA caps pinned memory at around half of RAM, so FreeToken pins what it can from the middle layers outward and OS-locks the rest, which works but copies more slowly.

Long Prompts Are the Bottleneck

Generating a token touches only a few experts per layer, but reading a long prompt does not. FreeToken's prefill guide explains that with offloaded experts, every MoE layer copies all of its experts from host to GPU for every prefill chunk, because a large chunk routes to nearly every expert anyway. Copy time per chunk is therefore roughly the total expert bytes divided by PCIe bandwidth, and the guide measures about 55.6 GB/s on PCIe 5.0. The default chunk is 8,192 tokens.

Put the earlier estimate through that formula. If a 284B model carries about 150 GB of expert weights, each chunk needs about 2.7 seconds of copying, which caps prefill at roughly 3,000 tokens per second while the copy is the bottleneck. A 100,000-token coding-agent context is 13 chunks, about 35 seconds before the first output token, and roughly twice that on a PCIe 4.0 slot with about half the bandwidth. This is our arithmetic using the project's formula, not a published benchmark.

That number explains several design choices. Because the copy cost is per chunk, not per token, raising --max-prefill-length gives the GPU more work to hide each copy behind, until compute catches up. --moe-prefill-hit-d2d (CUDA 13 or newer) skips experts already in the GPU cache so only misses cross PCIe. Overlap, on by default, copies layer N+1 while layer N computes, and the server logs a warning at startup if the expert cache is too small to hold the two staging layers it needs. And the semantic anchor checkpoints exist so an agent's tool call does not send the whole context back through this pipeline.

Install FreeToken and Serve a Model

The command-line engine needs Linux on x86_64, an NVIDIA GPU with driver r580 or newer (CUDA 13), and Python 3.10 or later, and the README lists native support for RTX 30, 40 and 50 series cards. If you would rather avoid the terminal, the desktop app for Windows and Linux at flashml.ai sets up the engine and gives you a GUI for running models, chatting and tuning. For the CLI, install with uv:

uv venv && source .venv/bin/activate
uv pip install "freetoken[accel]"

The PyPI package JIT-compiles its CUDA kernels on first use, so it needs a CUDA 13 toolkit with nvcc on your PATH. Nightly wheels with the kernels prebuilt are published on the repository's rolling nightly release; pin a wheel URL rather than the tag, because the tag moves every night.

Then start a server. --model takes a local checkpoint directory or a Hugging Face repo id, and the dtype, attention and MoE backends, cache sizes and tool-call and reasoning parsers all resolve from the checkpoint and the GPU:

ft serve --model ~/models/Qwen3.6-35B-A3B

The server is ready when the log says it is serving on 127.0.0.1:1919. It speaks the OpenAI API (/v1/chat/completions, /v1/responses, /v1/models) and the Anthropic API (/v1/messages, /v1/messages/count_tokens), so a client library for either works once you point its base URL at the server:

curl http://127.0.0.1:1919/v1/chat/completions -H 'Content-Type: application/json' -d '{"model": "Qwen3.6-35B-A3B", "messages": [{"role": "user", "content": "What is a Mixture-of-Experts model?"}], "max_tokens": 256}'

The reply comes back as one long line of JSON, and pasting it into a JSON formatter makes the choices and usage blocks readable. For a quick conversation without writing requests, ft shell opens a terminal chat attached to the running server, and ft shell --model starts an engine and chats in one process.

Point a Coding Agent at It

Local serving is most useful when the tools you already use can call it, and FreeToken has a shortcut for that. ft launch claude writes Claude Code's provider config, installs the CLI if it is missing and starts it against your server. The same command works for codex, opencode, openclaw, hermes and dsh, and --dry-run previews the changes first. The README names Codex, Claude Code, OpenCode, OpenClaw and DeepSeek Harness among the agents it works with.

Tool calling runs through parsers inferred from the model family, and reasoning models get their chain of thought split into a separate reasoning_content field. When you debug an agent, remember that in OpenAI-style responses a tool call's arguments arrive as a JSON-encoded string inside the JSON reply, full of escaped quotes; a JSON unescape tool turns them back into readable JSON.

By default the server binds to 127.0.0.1 and accepts any request, which is fine on a single machine. If you expose it to your network with --host, set --api-key (or the FREETOKEN_API_KEY environment variable) as well, so every route except /health requires the key as a Bearer token or an x-api-key header. A long value from a random string generator does the job. The server runs four requests at once by default, adjustable with --max-running-requests.

What to Watch Out For

FreeToken is very young. The repository is about three and a half months old, it had 473 open issues and pull requests on November 2, 2026, and its docs show a weight format still in motion: several notes say FTW checkpoints converted by older builds no longer load, and one warns that an old Qwen3.5, Qwen3.6 or Qwen3.8-27B conversion loads without an error but gives wrong output. If you convert checkpoints with ft checkpoint, plan to reconvert after upgrading, and run the bundled checkpoint diagnosis script when a model refuses to load.

Hardware support is narrower than "your gaming PC" suggests. The CLI is Linux x86_64 and NVIDIA only, there is no macOS build, Windows users get the desktop app or WSL with its pinned-memory cap, and AMD support for RDNA3 and RDNA4 cards on ROCm 7.14 is labelled experimental, without the CUDA-only kernel backends. Not every feature covers every model either: DeepSeek-V4 experts have no resident path, and DSpark speculative decoding is not served for DeepSeek-V4.1-Flash.

Finally, the abstract makes capability claims, not speed claims. It says which models run on which class of machine, not how many tokens per second you will get, so measure on your own hardware. ft bench bw reports your real PCIe and CPU bandwidth, and --moe-collect-stats logs the expert-cache hit rate. Together they tell you whether a model will feel interactive on your machine before you buy more RAM for it.

FAQs

What is FreeToken?

An open-source serving engine from FlashML-org, licensed under Apache 2.0, for running large Mixture-of-Experts language models on consumer hardware. It keeps experts in system RAM, caches the busiest ones on the GPU, and serves OpenAI and Anthropic compatible APIs. It had 15,782 stars in November 2026.

Can FreeToken really run a 284B model on a gaming PC?

Its paper reports a 284B model on a gaming desktop, but the limit is system RAM, not the GPU. At about 4.5 bits per weight such a model is roughly 160 GB, so by our estimate you need around 192 GB of RAM, plus a fast NVMe drive for some models.

What hardware does FreeToken need?

The CLI needs Linux on x86_64, an NVIDIA GPU with driver r580 or newer for CUDA 13 (RTX 30, 40 and 50 series are supported), and Python 3.10 or later. The desktop app runs on Windows and Linux. AMD RDNA3 and RDNA4 GPUs are experimental under ROCm 7.14.

Does FreeToken work on a Mac?

No. There is no macOS build: the engine targets Linux with NVIDIA GPUs, the desktop app is for Windows and Linux, and AMD support is still experimental.

Which models does FreeToken support?

Its known-good list includes DeepSeek-V4 and V4.1-Flash, GLM-4.7, GLM-5.2 and GLM-5.3-Flash, Qwen3, Qwen3.6 and Qwen3.8 models, gpt-oss, Gemma-4, and MiniMax-M2.5 and M3, among others. It loads Hugging Face safetensors directly and also reads GGUF files, in formats such as NVFP4, MXFP4, FP8 and BF16.

Is FreeToken compatible with the OpenAI API?

Yes. ft serve exposes /v1/chat/completions, /v1/responses and /v1/models in the OpenAI format and /v1/messages and /v1/messages/count_tokens in the Anthropic format on 127.0.0.1:1919, so existing client libraries work once you change the base URL.

Can I use FreeToken with Claude Code or Codex?

Yes. ft launch claude configures Claude Code to use your local server, installs its CLI if needed and starts it, and codex, opencode, openclaw, hermes and dsh work the same way. Add --dry-run to preview the config changes first.

Does FreeToken cost anything?

The engine is open source under the Apache License 2.0, so there is no licence fee or subscription; the costs are your own hardware and electricity. The desktop app for Windows and Linux is downloaded from flashml.ai.

Originally published at devpik.com/open-source/freetoken. Repo: FlashML-org/FreeToken.

Handy: Free Offline Speech-to-Text That Types What You Say

Muhammad Tayyab — Fri, 06 Nov 2026 07:30:09 +0000

Handy lets you type with your voice, for free, and completely offline. Press a shortcut, speak, and the words appear in any app, transcribed on your own computer with Whisper, never sent to the cloud. It works on Windows, macOS, and Linux, and it has 36,127 stars.

What Is Handy?

Handy is a free, open-source, and extensible speech-to-text application that works completely offline. Press a shortcut, speak, and your words appear in any text field, in any app. The transcription happens on your own computer, without sending any audio to the cloud.

The project states its case in four words: free, open source, private, and simple. Accessibility tooling belongs in everyone's hands, not behind a paywall. Open source means anyone can extend it and contribute to something bigger. Private means your voice stays on your computer. Simple means one tool, one job: transcribe what you say and put it into a text box.

It is a cross-platform desktop app built with Tauri and Rust, licensed under MIT, and the repository had 36,127 stars and 3,428 forks when we checked on November 1, 2026. The project site is handy.computer, and releases are published on GitHub. Note one branding detail from the license file: Handy itself is open source, but the Handy name, logo, icon, and brand assets are not, so unofficial forks and redistributions must use their own branding.

How It Works

Using Handy takes four steps. Press a configurable keyboard shortcut: hold it to record and release to stop, or tap it to toggle recording on and off. Hold-only and toggle-only modes are also available. Speak your words while the shortcut is active. Release, and Handy processes your speech. Then the transcribed text is pasted directly into whatever app you were using.

The process is entirely local. Silence is filtered using voice activity detection with Silero, so pauses do not become garbled text. Transcription uses your choice of models: Whisper models in Small, Medium, Turbo, and Large sizes, with GPU acceleration when available, or Parakeet V3, a CPU-optimized model with excellent performance and automatic language detection.

That local pipeline is the whole privacy story. There is no account, no server round trip, and no audio leaving your machine. The trade-off is the one every offline tool makes: you download a model file once, and the bigger models take real disk space and a capable machine, while the smaller ones run almost anywhere.

Install It in Minutes

Download the latest release from the GitHub releases page or from handy.computer. On macOS it is also available via Homebrew with brew install --cask handy, and on Windows via winget with winget install cjpais.Handy. Note that the Homebrew cask and winget package are not maintained by the Handy developers. On Debian or Ubuntu, install the downloaded .deb with apt so required dependencies are installed automatically, and do not use dpkg on its own unless the dependencies are already there.

After installing, launch Handy and grant the system permissions it needs, microphone and accessibility, then configure your preferred keyboard shortcut in Settings and start transcribing. If you want to control it from elsewhere, a Raycast extension can start and stop recording, browse transcript history, manage the dictionary, and switch models and languages.

Power users get more. Command-line flags can control a running instance: handy --toggle-transcription, --toggle-post-process, and --cancel, plus startup flags like --start-hidden, --no-tray, and --debug. An advanced debug mode, revealed with Cmd+Shift+D on macOS or Ctrl+Shift+D on Windows and Linux, exposes paste delay tuning and a Reliable Paste beta for apps where the standard clipboard paste misbehaves.

Models: Pick Your Size, Keep Your Privacy

Handy ships a model picker, and the choice is a classic size versus quality trade. Whisper Small is 487 MB, Medium is 492 MB in quantized form, Turbo is 1600 MB, and Large is 1100 MB quantized. Parakeet Unified EN 0.6B arrives as a single 731 MB file and is the recommended option when you want strong quality on CPU alone.

If you are behind a proxy, firewall, or restricted network where Handy cannot download models automatically, you can install them by hand. Find your app data directory in Settings, About, create a models folder inside it, drop the model file in with its exact filename, and restart Handy. Do not rename the files. Handy also picks up models already present in the shared Hugging Face cache, so a copy downloaded by another tool works without being moved.

Custom Whisper models work too. Drop any valid Whisper GGML .bin file into the models directory, restart, and it appears under Custom Models, named from its filename. Community models are user-provided and may not receive troubleshooting assistance, but the door is open for fine-tuned or community models the default list does not include.

Platform Quirks to Know

Handy works on Windows, macOS, and Linux, but each platform has quirks the project documents honestly. On Linux, reliable text input needs the right tool for your display server: xdotool on X11, wtype on Wayland, or dotool for both, which needs your user in the input group. Without them, Handy falls back to a method with limited compatibility, especially on Wayland. Wayland global shortcuts must also be configured through your desktop environment, using the CLI flags as the shortcut command.

Linux startup can also trip on a missing runtime library: if Handy fails with an error about libgtk-layer-shell.so.0, install libgtk-layer-shell0 on Ubuntu or Debian, gtk-layer-shell on Fedora, RHEL, or Arch. The recording overlay is disabled by default on Linux because some compositors treat it as the active window and steal focus, which breaks pasting back into the app that triggered transcription.

On macOS, a Bluetooth headset microphone may temporarily reduce playback quality while recording, because Bluetooth switches to bidirectional audio; keeping headphones as output and selecting a built-in or external mic avoids it. Shortcuts using the fn or Globe key only work on Apple keyboards, because fn is not part of the standard USB keyboard specification and third-party keyboards handle it in firmware. On Windows, Handy asks the Vulkan loader to skip implicit layers to avoid crashes from overlay and capture tools, which you can opt out of with an environment variable.

How to Try It

Install the release for your platform, grant microphone and accessibility permissions, and set a shortcut you will actually remember. A good first test is dictating into a plain text editor: hold the shortcut, say a sentence with a number and a name in it, release, and check what lands. If the text is right, try it in the app where you actually write, an email, a document, or a chat window, because pasting behavior can differ between apps.

Then pick your model deliberately. Start with a smaller Whisper model or Parakeet if you are on CPU, and move up only if accuracy disappoints you. If a previous clipboard item gets pasted instead of your transcription, open Debug mode and try Reliable Paste on macOS or Windows, or increase the paste delay, and test again in the app where it happened.

If you live on the command line or a tiling window manager, wire the CLI flags into your own shortcuts. On Sway or i3, bindsym $mod+o exec handy --toggle-transcription does the job, and on Hyprland the equivalent bind line works the same way. On Linux you can also trigger it with pkill -USR2, which simply delivers a signal and does not terminate the process.

What to Watch Out For

Handy is actively developed, and the project is transparent about its rough edges, which is a good sign, but set expectations accordingly. The known-issues list covers the platform quirks above, plus overlay and pasting behavior on Linux, and the troubleshooting docs are genuinely detailed, including the exact debug settings to try when paste misbehaves.

Release artifacts are signed with Tauri's updater signature format, and the project documents how to verify a download manually with minisign, explicitly warning not to use gpg for those .sig files. That is a nice touch for a privacy tool: the verification story is written down, not assumed.

Finally, remember the trade you are making. Offline means private and free of subscriptions, but it also means you manage models, disk space, and platform quirks yourself. If you want dictation that just works everywhere with no setup, a cloud service will feel smoother. If you want your voice to stay on your computer, cost nothing, and be open source, Handy is the tool built for exactly that, and its 36,127 stars suggest a lot of people wanted exactly that.

FAQs

What is Handy?

A free, open-source, cross-platform speech-to-text desktop app that works completely offline. Press a shortcut, speak, and your words appear in any app, transcribed on your own computer. It is built with Tauri and Rust, licensed under MIT, and had 36,127 stars in November 2026.

Does Handy send my voice to the cloud?

No. Transcription happens entirely on your own computer: Silero filters silence and Whisper or Parakeet transcribes locally. There is no account and no audio leaves your machine.

How do I use Handy?

Press a configurable keyboard shortcut, hold it to record and release to stop, or tap it to toggle recording, speak, and release. Handy transcribes with Whisper and pastes the text directly into whatever app you are using.

Which models can Handy use?

Whisper Small, Medium, Turbo, and Large, with GPU acceleration when available, and Parakeet V3, a CPU-optimized model with automatic language detection. You can also drop in custom Whisper GGML models, which appear under Custom Models after a restart.

How do I install Handy?

Download the latest release from GitHub or handy.computer. macOS users can use Homebrew (brew install --cask handy), Windows users winget (winget install cjpais.Handy), and Debian or Ubuntu users install the .deb with apt so dependencies resolve automatically. Then grant microphone and accessibility permissions and set a shortcut.

Does Handy work on Linux Wayland?

With caveats. You need wtype or dotool for text input, global shortcuts must be configured through your desktop environment using Handy's CLI flags, and the recording overlay is disabled by default because some compositors steal focus from it.

What if Handy pastes my old clipboard text instead of the transcription?

Open Debug mode with Cmd+Shift+D on macOS or Ctrl+Shift+D on Windows and Linux, try Reliable Paste (beta) on macOS or Windows, or increase the Paste Delay (After) setting, then test again in the app where it happened.

Is Handy really free?

Yes. It is free and open source under MIT. The Handy name, logo, icon, and brand assets are not open source, so unofficial forks must use their own branding, but the software itself costs nothing.

Originally published at devpik.com/open-source/handy. Repo: cjpais/Handy.

Claude Code Game Studios: Turn Your AI Into a 49-Agent Game Studio

Muhammad Tayyab — Fri, 06 Nov 2026 07:28:42 +0000

Claude Code Game Studios turns a single Claude Code session into a full game development studio. It gives you 49 specialized AI agents organized like a real studio, directors who guard the vision, department leads who own their domains, and specialists who do the hands-on work, plus 74 workflow skills and automated checks. It has 31,734 stars and works with Godot, Unity, and Unreal Engine.

What Is Claude Code Game Studios?

Building a game solo with AI is powerful, but a single chat session has no structure. Nothing stops you from hardcoding magic numbers, skipping design documents, or writing spaghetti code. There is no QA pass, no design review, and no one asking whether a feature actually fits the game's vision.

Claude Code Game Studios fixes that by giving your AI session the structure of a real studio. Instead of one general-purpose assistant, you get 49 specialized agents, 74 slash-command skills, 15 automated hooks, 14 path-scoped coding rules, and 62 document templates. It is built for Claude Code, licensed under MIT, and the repository had 31,734 stars and 4,336 forks when we checked on November 1, 2026.

The key idea: you still make every decision, but now you have a team that asks the right questions, catches mistakes early, and keeps the project organized from first brainstorm to launch. It is a template you clone to start your own project, not a game itself. Somebody else's game in your repo would be clutter, not evidence, so no sample games ship with it.

A Studio Hierarchy, Not a Single Chatbot

The 49 agents are organized into three tiers, matching how real studios operate. Tier 1 is the directors: creative-director, technical-director, and producer. Tier 2 is the department leads: game-designer, lead-programmer, art-director, audio-director, narrative-director, qa-lead, release-manager, and localization-lead. Tier 3 is the specialists: gameplay, engine, AI, network, tools, and UI programmers, systems, level, and economy designers, technical artists, sound designers, writers, world-builders, UX designers, prototypers, performance analysts, and more.

Each agent declares a model in its frontmatter. The three directors ask for Opus, the lead-programmer and fifteen specialists name Sonnet, and the remaining thirty inherit your session's model. Treat the tiers as seniority of role, not a billing plan: most of the studio runs on whatever model you are already using.

The template also includes agent sets for all three major engines. Use the set that matches your project: a Godot 4 specialist covering GDScript, shaders, and GDExtension; a Unity specialist covering DOTS/ECS, shaders and VFX, Addressables, and UI Toolkit; or an Unreal Engine 5 specialist covering GAS, Blueprints, replication, and UMG/CommonUI.

The Workflow: From /start to Launch

Everything runs through slash commands in Claude Code. Run /start and the system asks where you are, no idea, vague concept, clear design, or existing work, and guides you to the right workflow. From there, /brainstorm explores ideas, /setup-engine configures your engine, /design-system and /map-systems shape the game, /create-epics and /create-stories break work into stories, and /dev-story and /story-done carry each story through implementation.

Around that spine sit the phases a real studio runs: art bibles and asset specs, UX design and review, architecture decisions and reviews, design and code reviews, balance checks, scope checks, performance profiles, and tech-debt passes. QA gets its own battery: QA plans, smoke checks, soak tests, regression suites, and test-evidence reviews. Production covers milestone reviews, retrospectives, bug triage, and playtest reports, and release covers checklists, changelogs, patch notes, hotfixes, and day-one patches.

Team commands coordinate several agents on one feature: /team-combat, /team-narrative, /team-ui, /team-release, /team-polish, /team-audio, /team-level, /team-live-ops, and /team-qa. Delegation follows a clear model: directors delegate to leads, leads delegate to specialists, same-tier agents can consult each other but cannot make binding cross-domain decisions, and disagreements escalate to the shared parent, creative-director for design, technical-director for technical matters, with the producer coordinating cross-department changes.

How Much Process? The Rigor Setting

One setting controls how much process every skill enforces: modes.rigor in project.yaml, with three levels, minimal, standard, and full. It is a single front door over six knobs: which game design document sections are required, doc density, QA level, story granularity, review mode, and team size. /start asks it once instead of six times.

Minimal is the default, and the project is refreshingly honest about why. Four games were built from one brief at different rigor levels, and the documents each wrote before its first line of game code were counted: minimal wrote 1, the one-page brief, and standard wrote 30 over 58 minutes. All of them produced a running, tested game, and two blind reviewers plus a human playtest ranked the standard build last. The extra 29 documents bought traceability, not a better game.

Standard requires 5 game design document sections with balanced doc depth and lean review. Full requires all 8 sections, thorough docs, full QA evidence on every story type, and full director review. Raise it in one /settings call when your project grows, and /help and /gate-check will suggest it when they see the signs. Two escape hatches keep it from being blunt: system_overrides holds one system to a higher standard than the rest, so your combat system gets the full treatment while everything else stays light, and testing.strict sets per test type whether missing evidence blocks a story or merely warns.

Guardrails That Run Themselves

Fifteen hooks run automatically on every session. Commit validation checks for hardcoded values, TODO format, JSON validity, and design-doc sections. Push validation warns on pushes to protected branches and on tags, merges, releases, and store uploads. Read validation refuses a whole-file read of a design doc over 40 KB and answers with its headings, so the retry reads one section. Write validation warns, never blocks, when a write would break a stated rule, and asset validation checks data-file JSON and naming.

Session hooks show the current branch and recent commits on open, detect fresh projects and suggest /start, log compactions, archive session logs, and keep an audit trail of every subagent invocation, including a warning when a subagent stops without writing the file its brief named. Permission rules auto-allow test runs and block dangerous operations like force push, rm -rf, and reading .env files.

Coding standards are enforced by file location: gameplay code must be data-driven and use delta time, core code must avoid allocations in hot paths, networking must be server-authoritative with versioned messages, UI code must not own game state and must be localization-ready, and tests follow naming and coverage rules. And there is one rule that matters more than any test: a story that changes anything the player sees is not closed until the game has been launched, observed, and a screenshot retained as evidence. A passing test says nothing about a menu drawn off-screen.

How to Try It

You need Git, Claude Code, Python 3, and Bash. Python reads project.yaml for every skill and hook, so without it every setting silently falls back to its default. The jq tool is recommended for hook validation. Hooks fail gracefully if optional tools are missing, with one deliberate exception: a commit that stages data JSON is blocked when there is no Python to validate it.

Clone the template and open Claude Code in the project root, the folder holding CLAUDE.md and project.yaml. Starting in a subfolder like src/ skips the project's hooks, deny rules, and ask-first permission mode. Then run /start. If you already know what you need, jump straight there: /brainstorm for ideas from scratch, /setup-engine godot 4.7 to configure your engine, or /project-stage-detect to analyze an existing project.

A good first test is a small game at minimal rigor: brainstorm a one-page brief, create stories, and run one story end to end. Watch for the sequence the studio promises: questions before solutions, options with pros and cons, your decision, a draft shown before finalizing, and approval before anything is written. If your agent skips straight to code, the install is not active, and starting from the project root usually fixes it.

What to Watch Out For

This is collaborative, not autonomous, by design. Every agent follows an ask, present options, you decide, draft, approve protocol, and nothing gets written without your sign-off. The guided and autonomous automation settings trade some of those prompts for speed, but out of the box you are the decision-maker at every step. If you want an autopilot that builds a game while you watch, this is not it.

It also costs more than a single chat session. Directors on Opus, sub-agents per story, reviews between tasks, and QA evidence all add up, which is another reason minimal rigor is the default. And because it is a template you are meant to edit, the project ships studio-tests, a way to check that an edited or newly written skill still holds up, with structural linting, category rubrics, behavioral specs, and coverage audits. It tests the framework, never your game.

Finally, remember what you are cloning: a process, not a product. There is no game to play in the repo, and that is deliberate. The value is the studio structure itself, and whether it helps you ship depends on whether you wanted that structure in the first place. For a game jam, minimal rigor keeps it out of your way. For a project you plan to finish, the directors, leads, and specialists are there to keep it organized all the way to launch.

FAQs

What is Claude Code Game Studios?

A template that turns one Claude Code session into a full game development studio: 49 specialized AI agents in a director, lead, and specialist hierarchy, 74 slash-command skills, 15 automated hooks, 14 coding rules, and 62 document templates. It is open source under MIT and had 31,734 stars in November 2026.

Which game engines does it support?

Godot 4, Unity, and Unreal Engine 5, each with its own specialist agent set: GDScript, shaders, and GDExtension for Godot; DOTS/ECS, shaders and VFX, Addressables, and UI Toolkit for Unity; and GAS, Blueprints, replication, and UMG/CommonUI for Unreal.

How do I start a game with it?

Clone the repo, open Claude Code in the project root (the folder holding CLAUDE.md and project.yaml), and run /start. It asks where you are, no idea, vague concept, clear design, or existing work, and guides you to the right workflow.

What is modes.rigor?

One setting in project.yaml that controls how much process every skill enforces: minimal (jam-game speed, no design docs required), standard (5 required design-doc sections), or full (all 8 sections, full QA evidence, full director review). Minimal is the default, because the project's own measurement found heavier process bought traceability, not a better game.

Does it build the game by itself?

No. It is collaborative, not autonomous. Agents ask questions before proposing solutions, present 2 to 4 options with pros and cons, and nothing gets written without your approval. You make every decision; the agents provide structure and expertise.

Does the repo include a playable game?

No, deliberately. It is a template you clone to start your own project, and somebody else's game in your repo would be clutter, not evidence. The value is the studio structure: agents, skills, hooks, rules, and templates.

What do I need installed?

Git, Claude Code, Python 3, and Bash. Python reads project.yaml for every skill and hook, so without it settings silently fall back to defaults. The jq tool is recommended for hook validation.

Is Claude Code Game Studios free?

Yes. It is open source under the MIT license. The maintainer accepts voluntary support through Buy Me a Coffee and GitHub Sponsors.

Originally published at devpik.com/open-source/claude-code-game-studios. Repo: Donchitos/Claude-Code-Game-Studios.

Superpowers: The Open-Source Method That Stops Your AI Agent Rushing to Code

Muhammad Tayyab — Fri, 06 Nov 2026 07:26:37 +0000

Superpowers stops your AI coding agent from jumping straight into code. It asks what you actually want, plans step by step, writes tests first, and sends sub-agents to do each task, with a review after every one. It works with Claude Code, Cursor, Codex, Copilot, Gemini and more, and it has 309,623 stars, making it one of the most starred developer projects on GitHub.

What Is Superpowers?

Superpowers is a complete software development methodology for your coding agents, built on top of a set of composable skills and some initial instructions that make sure your agent uses them. It is built by Jesse Vincent and the team at Prime Radiant, licensed under MIT, and the repository had 309,623 stars and 27,550 forks when we checked on October 31, 2026.

The core idea is simple, and it fixes the most common failure of AI coding. Left alone, a coding agent jumps straight into writing code, guesses at what you want, and produces something that sort of works and is hard to change. Superpowers changes the default. From the moment you fire up your agent, it steps back and asks what you are really trying to do, instead of trying to write code first.

Because the skills trigger automatically, you do not need to do anything special once it is installed. Your coding agent just has Superpowers. The skills fire at the right moments: brainstorming before building, planning after design approval, test-driven development during implementation, and code review between tasks. They are mandatory workflows, not suggestions your agent can skip when it feels confident.

Brainstorm First, Then Plan

The workflow starts with brainstorming. The agent draws out what you actually want, and why, through questions that get you describing it, then plays its understanding back for correction. Small changes get agreed in chat. Bigger projects get a written design document that a builder could plan from, shown to you in chunks short enough to actually read and digest.

After you sign off on the design, the agent puts together an implementation plan that is clear enough for an enthusiastic junior engineer with poor taste, no judgment, no project context, and an aversion to testing to follow. That is the project's own bar, and it is deliberately low: if the plan only works when read by an expert, it is not a good plan. Work is broken into bite-sized tasks of 2 to 5 minutes each, and every task has exact file paths, complete code, and verification steps.

Then, once you say go, the agent launches a subagent-driven process. Fresh sub-agents work through each engineering task, with inspection and review of their work as they go. It is not uncommon for an agent to work autonomously for a couple of hours at a time without deviating from the plan you put together, because the plan, not the agent's enthusiasm, is what is driving.

Test-Driven by Default

Superpowers emphasizes true red-green test-driven development, YAGNI, which means you are not gonna need it, and DRY, do not repeat yourself. During implementation, the test-driven-development skill enforces the red-green-refactor cycle: write a failing test, watch it fail, write the minimal code to pass, watch it pass, then refactor. Code written before tests gets deleted.

That sounds strict, and it is meant to be. AI agents are very good at writing plausible code that has never been run, and tests are the cheapest way to catch that. The verification-before-completion skill adds a second guard: the agent must ensure something is actually fixed before declaring it done, instead of claiming success from reading its own output.

Between tasks, the requesting-code-review skill reviews work against the plan and reports issues by severity. Critical issues block progress. When tasks complete, the finishing-a-development-branch skill verifies tests, presents options to merge, open a pull request, keep or discard the branch, and cleans up the worktree. Nothing merges on vibes.

The Skills Inside

Superpowers ships a library of skills grouped by job. Testing has test-driven development with a testing anti-patterns reference. Debugging has systematic debugging, a four-phase root cause process, verification before completion, and diagnosing-superpowers, which works out what went wrong in a session with line-level evidence and can package a scrubbed bundle for a bug report.

Collaboration skills cover the whole lifecycle: brainstorming, writing plans, executing plans inline, dispatching parallel agents, requesting and receiving code review, using git worktrees for isolated branches, finishing a development branch, and subagent-driven development with two-stage review, first for spec compliance, then for code quality. Meta skills cover writing new skills and the using-superpowers bootstrap itself.

The philosophy underneath is four lines: test-driven development, write tests first, always. Systematic over ad-hoc, process over guessing. Complexity reduction, simplicity as the primary goal. Evidence over claims, verify before declaring success. If those sound like rules a good senior engineer would enforce on a team, that is the point. Superpowers is a senior engineer's habits, packaged as skills an agent cannot quietly drop.

Works With Your Agent

Superpowers is not tied to one tool. It installs as a plugin or extension for Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot CLI, and many more, including Antigravity, Devin, Factory Droid, Grok Build, Kimi Code, OpenCode, Pi, Qwen Code, Hermes Agent, and Muse itself. Installation differs by harness, and if you use more than one, you install it separately for each one.

For Claude Code, install it from Anthropic's official plugin marketplace with /plugin install superpowers@claude-plugins-official, or register the Superpowers marketplace and install from there. For Cursor, install from the marketplace in Agent chat. For Codex, find it in the official plugin marketplace. The README lists every harness with its exact command, so pick yours and follow that one.

One detail worth knowing: skills trigger automatically, but the bootstrap that makes them trigger is injected at session start. If a very long session compacts and skills stop firing, start a fresh session. On Hermes Agent, which has no post-compaction hook, the same applies. And if a session misbehaves, ask your agent to figure out what went wrong with Superpowers in that session, and the diagnosing skill will read the transcript and report what happened with evidence.

How to Try It

Pick your coding agent and install the plugin. In Claude Code, run /plugin install superpowers@claude-plugins-official. Then start a fresh session and describe something you want to build. A working install auto-triggers brainstorming before any code is written, so the first thing you should see is questions about what you want, not code.

A good first test is a small project with a real requirement, like a todo app with a specific behavior, or a small feature on a codebase you already have. Watch for the sequence: questions first, a design played back for correction, a plan broken into small tasks with exact files and verification steps, tests before code, and a review after each task. If your agent skips straight to code, the install is not active, and a fresh session usually fixes it.

Updating is often automatic, but it depends on your harness. The project also offers commercial services for enterprises that want support, additional tooling, or managed spending, through Prime Radiant. For everyone else, the open-source version is the whole methodology, free under MIT, and it is what the 309,623 stars are for.

What to Watch Out For

Superpowers changes how it feels to work with an agent, and that takes a session or two to get used to. If you are used to getting code in the first reply, the questions will feel slow. They are the point. The methodology trades a fast first draft for a plan you can trust and code that has been tested and reviewed, and for anything bigger than a toy, that trade wins.

It also costs more tokens than letting an agent freestyle. Sub-agents per task, reviews between tasks, and tests before code all add up. The cheaper executing-plans mode implements every task inline in the current session with one fresh review of the whole branch at the end, instead of a sub-agent per task, if you want to save on that cost.

Finally, Superpowers does not accept agent-written pull requests that fix issues filed by someone else unless a maintainer asked for one, and it does not generally accept contributions of new skills. Skill updates must work across all the coding agents it supports. Those rules keep the methodology consistent, but they mean the project grows carefully rather than fast. For users, that is a feature: the workflow you learn today is the workflow that will still be there tomorrow.

FAQs

What is Superpowers?

A complete software development methodology for coding agents, built by Jesse Vincent and Prime Radiant. It is a set of composable skills that make your agent brainstorm before building, plan in bite-sized tasks, write tests first, and build with sub-agents and reviews. It is open source under MIT and had 309,623 stars in October 2026.

How does Superpowers change the way my coding agent works?

Instead of jumping straight into code, your agent first asks what you really want, plays its understanding back for correction, writes a design, breaks it into 2 to 5 minute tasks with exact files and verification steps, then builds with tests first and a review after each task. The skills trigger automatically and are mandatory workflows, not suggestions.

Which coding agents does Superpowers work with?

Claude Code, Cursor, Codex, GitHub Copilot CLI, Gemini CLI, and many more, including Antigravity, Devin, Factory Droid, Grok Build, Kimi Code, OpenCode, Pi, Qwen Code, Hermes Agent, and Muse. Install it separately for each harness you use.

How do I install Superpowers in Claude Code?

Run /plugin install superpowers@claude-plugins-official in Claude Code, or register the Superpowers marketplace with /plugin marketplace add obra/superpowers-marketplace and install from there. Start a fresh session and describe something to build; brainstorming should trigger before any code is written.

Does Superpowers use test-driven development?

Yes, true red-green TDD is a core rule. The agent writes a failing test, watches it fail, writes minimal code to pass, watches it pass, then refactors. Code written before tests gets deleted, and a verification skill checks work is actually complete before the agent declares success.

What is subagent-driven development in Superpowers?

After the plan is approved, fresh sub-agents work through each engineering task, with inspection and review after each one. A cheaper alternative, executing-plans, implements every task inline in the current session with one fresh review of the whole branch at the end.

Is Superpowers free?

Yes. It is open source under the MIT license. Prime Radiant offers commercial services for enterprises that want support or managed spending, but the methodology itself is free.

What if Superpowers stops working in a long session?

Start a fresh session, since the bootstrap that triggers skills is injected at session start and a compacted session can lose it. You can also ask your agent to figure out what went wrong with Superpowers in that session, and the diagnosing skill will report what happened with line-level evidence.

Originally published at devpik.com/open-source/superpowers. Repo: obra/superpowers.

Claude SEO: The Open-Source SEO Audit That Works Like an Agency

Muhammad Tayyab — Fri, 06 Nov 2026 07:24:32 +0000

Claude SEO gives your website a full SEO audit, like hiring an agency, except it is free and it finishes in 10 to 15 minutes. It checks technical SEO, content quality, and how likely ChatGPT and Google's AI are to cite your pages, with up to 17 specialist agents working on your site at once. It has 24,684 stars, and its own site pulled 10.8K Search Console clicks in its first 12 weeks.

What Is Claude SEO?

Claude SEO is a free, open-source SEO plugin for Claude Code, built by Agrici Daniel and licensed under MIT. Give it any website and it runs a full SEO audit in 10 to 15 minutes, then hands you a clear action plan sorted by what matters most. The repository had 24,684 stars and 3,284 forks when we checked on October 31, 2026, and it is built from 26 sub-skills and 19 specialist agents.

It checks everything a good SEO consultant would. Technical SEO covers crawlability, indexing, sitemaps, robots.txt, redirects, page speed and Core Web Vitals. Content quality covers E-E-A-T, which stands for experience, expertise, authority and trust, plus thin pages and topic coverage. Structured data checks find, validate and write Schema.org markup for rich results. Local and e-commerce SEO covers Google Business Profile, reviews, map pack, product pages and international sites. And AI search, called GEO, scores how likely Google AI Overviews, AI Mode, ChatGPT, Perplexity and Gemini are to cite your pages.

The project's own site is the proof it points to. The site claude-seo.md was audited with Claude SEO from day one and picked up 10.8K Search Console clicks in its first 12 weeks, with a 99 mobile PageSpeed score. That is the project's own marketing, not an independent test, but it shows what the tool is built to chase: rankings in Google and citations in AI answers, not just a green score in a dashboard.

How an Audit Works

An audit runs in three steps. First, Claude SEO learns your site. It detects the type of business, SaaS, local, e-commerce, publisher or agency, and adjusts its checks to fit. Second, the team fans out. Up to 17 specialist agents audit the site in parallel, covering technical SEO, content, schema, speed, AI search and more. Third, you get a plan, not a pile of warnings. Findings are scored and sorted into a prioritized action plan, and every recommendation explains what it is based on, what it depends on, and how you will know it worked.

Reports are saved as Markdown files on your own machine, and the /seo google report command turns them into a polished PDF. The starting command is /seo audit with your URL. A single page in depth is /seo page, AI search readiness is /seo geo, structured data is /seo schema, and local SEO is /seo local. There are 30 core and extension commands in six groups, from audits and planning to technical SEO, content, schema and AI search, local and commerce, and extensions.

One design choice matters for trust. Claude SEO runs on your machine inside Claude Code, so your data stays with you. No SEO service or third party sees your data unless you connect an extension or API yourself. The pages you audit are sent to Claude, Anthropic's model, the same as anything else you work on in Claude Code, and some checks read public sources such as Wikipedia, Reddit and Common Crawl.

The 19-Agent Team

The team is the product. A technical SEO lead checks the foundations, a content editor checks E-E-A-T and quality, a structured data engineer handles schema, a sitemap architect handles sitemaps, and a performance engineer handles speed. Around them sit specialists for visual QA, AI search, agent readiness, local SEO, maps, Google data, backlinks, topic strategy, search experience design, change monitoring, e-commerce and strategy.

Five agents that need more judgment run on Opus and the rest on Sonnet, which is why a full audit uses more of your Claude plan than a single-page check. You can change any agent's model in its file under the agents folder. The split is also why the audit is fast: the agents work in parallel instead of one long checklist, so a full site audit lands in 10 to 15 minutes where doing it by hand takes 4 to 8 hours and an agency takes 1 to 3 weeks, by the project's own comparison.

Two specialist roles are worth knowing because they are newer than classic SEO. The AI search analyst scores how quotable your pages are for AI answers and checks that AI crawlers can reach them. The agent readiness analyst checks how well AI agents can use your site, covering Lighthouse Agentic Browsing, AI agent access, llms.txt, Markdown versions of pages and WebMCP. These are the checks that did not exist in SEO tools a few years ago, and they are the reason this project blew up in 2026.

AI Search Readiness

Google says optimizing for AI search is still SEO, and Claude SEO takes that literally. It starts with the basics AI answers rely on: being indexed, fast and clear. Then /seo geo scores how easy your pages are to quote, checks that AI crawlers can reach them, and looks at your brand's presence on Wikipedia, Reddit, YouTube and LinkedIn.

This is where most older SEO tools fall behind. They were built for ten blue links, and AI search coverage is often months behind in their checklists. Claude SEO follows Google's own documentation, including the AI Optimization Guide, and its extension commands go further: SE Ranking tracks your share of voice across ChatGPT, Gemini, Perplexity, AI Overviews and AI Mode, and Profound tracks when AI models cite your site over time. The Bing extension adds Bing Webmaster Tools plus instant IndexNow submission.

The honest framing is that no tool can guarantee an AI citation. What Claude SEO gives you is the checklist that makes citation possible: crawlable pages, clear facts, structured data, and a brand footprint AI models can find. If your pages are not indexed or your content is thin, no amount of AI-specific tuning will fix that, and the audit says so in that order.

Who It Is Built For

SEO agencies get weekly audits for every client instead of quarterly ones, with change monitoring to catch problems in between. The drift commands take SQLite snapshots of a site and compare them over time, so a broken redirect or a lost page shows up before a client notices. In-house SEO teams at SaaS, publishing and e-commerce companies get a second pair of eyes before every review, AI search included. Freelance SEO consultants can run an audit on the first call and show a real score and the top fixes before writing a proposal.

It is also useful for site owners who are not SEOs at all. The action plan is written so each fix says why it matters and how to verify it worked, which means you can hand it to a developer or work through it yourself without learning SEO first. And because reports are plain Markdown and JSON files you keep, you are not locked into a dashboard subscription to see your own audit history.

The cost comparison is the project's main sales pitch, and it is worth stating plainly. Doing it by hand costs billable hours, an agency costs $2k to $15k or more per project, and SEO audit software runs $99 to $999 a month. Claude SEO is free with your Claude Code plan, with no per-site pricing, no usage limits and no tracking. A few optional extensions connect to paid services where you bring your own account, but everything works without them.

How to Try It

You need Claude Code 1.0.33 or newer. Run these three commands inside it, and /seo setup prepares everything Claude SEO needs, its own Python environment and a headless browser, without touching the rest of your system. Run /seo doctor any time to check it. The commands are: /plugin marketplace add AgriciDaniel/claude-seo, then /plugin install claude-seo@agricidaniel-claude-seo, then /seo setup.

Manual install works too. Clone the repo and run the install script on macOS or Linux, or the PowerShell installer on Windows. The project deliberately recommends git clone over piping a remote script into a shell, because Claude Code's own security guardrails flag that pattern as a supply chain risk, and cloning lets you inspect the installer before running it.

Your first audit is one command: /seo audit with your site URL. Try /seo page on a single page for depth, /seo geo for AI search readiness, and /seo schema to check and generate structured data. If you want real field data instead of lab estimates, connect the free Google APIs, PageSpeed Insights, Chrome UX Report, Search Console and Google Analytics 4, with /seo google setup. Your keys stay on your machine.

What to Watch Out For

There are a few honest limits. Without Google API keys, Core Web Vitals are lab estimates and indexing is inferred from the page rather than confirmed. Pages that load key content only after scrolling or clicking can give noisy results. A full audit uses more of your Claude plan than a single-page check, because five agents run on Opus, so heavy users should expect that cost.

Claude SEO is also not a replacement for everything. Crawlers like Screaming Frog crawl faster and deeper, and big SEO suites have their own backlink databases that this tool does not. What it does instead is explain what it finds, sort it by impact, cover AI search in depth, and let you ask follow-up questions in plain English. Many people use both, and the README says so itself.

Finally, keep expectations straight about what an audit can do. It finds problems and ranks fixes, but it does not fix your site for you, and it cannot guarantee rankings or AI citations. Used that way, as a fast, free, repeatable audit with a plan attached, it is one of the most useful SEO tools available right now, and the 24,684 stars suggest a lot of people agree.

FAQs

What is Claude SEO?

A free, open-source SEO audit plugin for Claude Code by Agrici Daniel. It checks technical SEO, Core Web Vitals, content quality, Schema.org structured data, AI search readiness, local SEO, e-commerce and international SEO, then gives you a prioritized action plan. It is built from 26 sub-skills and 19 specialist agents and licensed under MIT.

How long does a Claude SEO audit take?

A full website audit takes 10 to 15 minutes, with up to 17 agents working on the site in parallel. Doing the same audit by hand takes 4 to 8 hours, and an agency takes 1 to 3 weeks, by the project's own comparison.

How many agents work on an audit?

The project has 19 specialist agents, and up to 17 work on a site at the same time during a full audit. Five agents that need more judgment run on Opus and the rest on Sonnet.

Does Claude SEO help with AI search like ChatGPT and Google AI Overviews?

Yes. Its GEO checks score how likely Google AI Overviews, AI Mode, ChatGPT, Perplexity and Gemini are to cite your pages, verify AI crawlers can reach them, and look at your brand's presence on Wikipedia, Reddit, YouTube and LinkedIn. Extensions add share-of-voice tracking and citation tracking over time.

Is Claude SEO really free?

Yes. It is MIT licensed, with no per-site pricing, no usage limits and no tracking. You only need Claude Code. A few optional extensions connect to paid services where you bring your own account, but everything works without them.

Do I need API keys for Claude SEO?

No. It works out of the box. If you want real field data, you can connect free Google APIs such as PageSpeed Insights, Chrome UX Report, Search Console and Google Analytics 4 with /seo google setup. Your keys stay on your machine.

How do I install Claude SEO?

You need Claude Code 1.0.33 or newer. Inside it, run /plugin marketplace add AgriciDaniel/claude-seo, then /plugin install claude-seo@agricidaniel-claude-seo, then /seo setup. Then run /seo audit with your site URL for your first full audit.

Does Claude SEO work on JavaScript sites like Next.js or React?

Yes. When a page needs JavaScript to show its content, Claude SEO opens it in a headless browser automatically, so single-page apps are audited as visitors see them.

Originally published at devpik.com/open-source/claude-seo. Repo: AgriciDaniel/claude-seo.