In March 2026 Andrej Karpathy released AutoResearch, an experiment in which an AI agent improves code on its own, round after round, while the person sleeps. Behind it is a way of working with AI that is useful well beyond research. Here is what AutoResearch is according to Karpathy’s own materials, how we apply his method when programming with AI, and why we think HTML, especially vertical HTML, is the best format for reviewing what a model produces.
What AutoResearch is
AutoResearch is a public repository Karpathy opened in March 2026. The idea, in his words: “give an AI agent a small but real LLM training setup and let it experiment autonomously overnight.” The agent changes the code, trains, checks whether the result improved, keeps or discards the change and starts again. As the README puts it, “You wake up in the morning to a log of experiments and (hopefully) a better model.”
Three files in the repository matter. prepare.py holds data preparation and evaluation, and is never modified. train.py holds the model and the training loop, and is the only file the agent edits. program.md holds the instructions and is edited by the person. Every training run lasts exactly 5 minutes, so experiments can be compared with each other.
In a post on March 9, Karpathy says he left the agent working on its own and that, before accepting its improvements, he tested them himself on larger models. What he points out about the agent: “It really looked at the sequence of results of experiments and used that to plan the next ones.”
The Karpathy method, piece by piece
Instructions are written in natural language. According to the README, the person’s job is to write program.md, which Karpathy describes as “essentially a super lightweight “skill””, the same idea we cover in our article on AI agent skills. That file sets the goal (“get the lowest val_bpb”), what the agent may touch and a simplicity rule: “All else being equal, simpler is better.”
The metric is decided before starting and the agent cannot change it. Results are scored with val_bpb (lower is better), and the function that computes it lives in prepare.py, which is read-only for the agent: “The evaluate_bpb function in prepare.py is the ground truth metric.” If the agent could touch the scoring, changing the grade would be easier than improving the model.
Every round is logged. The agent records each experiment in results.tsv: the commit, the result, a short description and whether the change stays (keep), is thrown away (discard) or failed (crash). If the result doesn’t improve, it goes back to where it started with git.
The person reviews the results and improves the instructions. The loop doesn’t stop to ask whether it should continue, because the person may be asleep, so the human work happens before and after each batch. In another post, Karpathy admits he spent more time tuning how the agent works than on the code itself: “I almost feel like I’ve iterated more on the “meta-setup” where I optimize and tune the agent flows even more than the nanochat repo directly.”
How to apply the Karpathy method when programming with AI
AutoResearch trains language models, but the structure works for any software task that can be measured. Karpathy makes the point in his March post: any metric that is reasonably efficient to evaluate lends itself to this loop. This is how we apply it at LetBrand with Code and other agents, and it is our answer when people ask us how to work with AI on real projects.
First, decide whether a loop is worth it. It makes sense when the task repeats, when a test can tell without human help whether the result is right, and when the agent can run what it builds and see what breaks. A loop uses a lot of your plan’s allowance, because the agent rereads the project every round. For a one-off job, a good prompt is enough.
Next, the checks are written before the code. The agent drafts the tests for the new feature, we approve them, and they are protected so the agent can’t edit them, just like prepare.py in AutoResearch.
Finally, one feature per loop and one log entry per round. In each round the agent notes what it tried and which checks still fail. That log is what we read at the end and what we use to improve the instructions, as Karpathy does with his program.md. If you are just starting, our guide on how to build an AI agent from scratch covers the basic pieces.
Passing every test doesn’t guarantee the agent did what you wanted. It can follow the rules you gave it and leave the screen your client will use unconnected. That is why the last step is to look at the result, and that is where HTML comes in.
Karpathy and HTML: understanding what AI does
On October 2, 2026, Karpathy posted a list of formats on X for better understanding what a language model gives you back. He opens with: “We’ll be spending a lot more time trying to understand the outputs of language models.”
He lists the formats in order, each introduced as better than the last: writing in ASD-STE100, a controlled language that originated in aerospace maintenance documentation; then diagrams; and third, web pages: “Ask for output “in HTML” to get a beautiful, interactive webpage. LLMs are getting really good at frontend and can create beautiful experiences, animations, etc.”
HTML is not the top of his list. The format he likes most is custom explainer videos: “The output format I am most bullish on is fully custom / bespoke explainer videos generated on any arbitrary topic.”
For us, this post and AutoResearch belong together: if an agent works alone for hours, the human part is mostly understanding what it did. Karpathy does not say HTML is the format of the future. What follows is our reading, and we put it forward as LetBrand’s opinion.
Why we think HTML for AI output will keep growing
Models write HTML very well, as Karpathy says about frontend work. In our experience, a report with tables, charts and tabs is usually usable on the first try, and fixing it means asking in the same chat.
Reviewing the result is faster when you can see it. The more AI produces, the more time goes into checking what it did, and in our view that is now the bottleneck. Ask an AI to compare three suppliers and get back a coloured table with totals, and within seconds you notice a missing supplier or a figure that doesn’t add up. In a long block of text that slips past.
The same goes for the loop described above: in our opinion, the report for each round is easier to follow as an HTML page showing what changed and what still fails, shared with a link. Whoever has to sign off can move from one round to the next on their phone.
For reports, presentations and small tools, we think HTML beats Word, Excel or PowerPoint, because a page can carry filters, tabs or a calculator and a PDF can only be read.
Why LetBrand is betting on vertical HTML
At LetBrand we think HTML is the format with the most future for what AI produces, and we have made it our flagship. Vertical HTML especially: pages designed for the phone, read top to bottom with a thumb.
The reason is practical. Whatever you send a client over WhatsApp or email is often opened on a phone. Landscape slides make people zoom in or turn the screen. A vertical page reads like any website and can carry charts, buttons or a form without anyone installing anything.
That is why we design our presentations and microsites for the phone first and adapt them to desktop afterwards. It is also why we add an agent to them: if the page is already in the client’s pocket, it can answer their questions right then, without waiting for a meeting.
How to share HTML made with AI
The simplest way is to send the file, which opens in any browser. If the page loads libraries or fonts from the internet, someone opening it offline may see it broken, so ask the model to put everything in a single file.
The second way is to publish it on your own website, under your domain, with no sign-in required.
The third is to keep it inside the AI platform. offers ChatGPT Sites, available for workspaces and Plus and Pro accounts, to build and publish websites and lightweight apps from . In , artifacts can be shared by link, but anyone opening one needs a account, except for legacy artifacts published from a chat.
What to check before you send AI-generated HTML
This is where the Karpathy method comes back, applied to a page. Before you ask for it, write down what it must contain for you to accept it: which data has to appear and what the recipient needs to be able to do with it. With that list written, reviewing means checking it item by item.
Code that runs without errors, or a model saying it has checked its work, does not guarantee the result is right. Open the file in a browser, on a laptop and on a phone, and see whether the tables fit the screen and the buttons respond. Also check the figures against the original source, especially anything the model calculated. And remember that anyone can read what is inside the file by opening its source code, even if the page doesn’t display it: if there is data the recipient shouldn’t see, remove it before you generate the page.
How LetBrand can help
If you want your presentation to become a page that also answers questions, we turn it into a presentation microsite with an agent, with its own link and no or account needed to open it. If you would rather it lived inside or , we prepare a ChatGPT Site or a Claude artifact: we build the Site and publish it for you. And if you need an assistant connected to your documents or catalogue, see our custom chatbots or try the guided demo. Tell us which report, presentation or tool you want to turn into HTML and we’ll send you a quote.