Quick answer
Long-running AI agents stay on track when they can read your current decisions, worked examples and up-to-date instructions, not just raw facts. In his latest video, Nate B Jones argues that the labs’ headline runs (OpenAI sessions lasting hundreds of hours, an Anthropic experiment with 1,000+ sub-agents over eight days) are less about smarter models and more about structure. Keep your project information in one organised place, treat it a bit like code, share skills across the team, and judge success by how rarely you have to explain yourself again.
Key takeaways
- The bottleneck is the assignment, not the data. Nate’s own research run produced 1,000 questions when what he really needed was the 50 most valuable answers.
- “Right context” means four things: facts, the decisions you made along the way, examples you developed and instructions that change as you learn.
- Put project information where agents can find it, organised like a code repository, even for non-technical work such as proposals.
- Shared, team-built skills beat personal ones. Everyone’s AI should follow the same recipe against the same data.
- Measure interruptions, not just time saved. If you keep re-explaining things, or your agent never asks you a question, the structure needs work.
In this guide
- What are long-running AI agents doing now?
- Why does an all-night AI run leave you with cleanup?
- What is the “right context” for long-running AI agents?
- What does “treat project information like code” mean?
- Why should skills be built for the team, not for you?
- How do roles and version rules stop collisions?
- How do you know it is working?
- How can you start on your own this week?
- Watch: the source video
- Frequently asked questions
- Related posts
Most of us are a long way from leaving an AI agent running for days. We are still re-typing the same instructions and fixing the same mistakes. That gap is what this video tackles, and it is useful whether you run a team or work on your own. Below we summarise Nate’s argument in plain English, separate what the labs reported from what Nate recommends, and turn it into steps you can try.
What are long-running AI agents doing now?
Nate opens with three recent reports from the big AI labs. These are the companies’ own claims, shown on screen in the video, rather than independent tests:
| Who | What they reported | Date shown |
|---|---|---|
| OpenAI | Several continuous sessions ran for hundreds of hours, finding and fixing edge cases in its new code-management system | 2 Nov 2026 |
| Anthropic | Claude coordinated more than 1,000 sub-agents working around the clock for eight days to build a prototype operating system that boots on a laptop | 9 Nov 2026 |
| Internal teams have seen Gemini 4 Carbon run for days on hard engineering problems | 10 Nov 2026 |
His point is simple: we now know these systems can work for a long time if they are set up well. The interesting question is what “set up well” means for the rest of us.
🔎 Unconfirmed / rumour: The lab figures above are self-reported. An eight-day experiment by one engineering team does not mean an off-the-shelf agent will behave the same way on your business files.
Why does an all-night AI run leave you with cleanup?
Because a long run magnifies any gap in what the agent knows. Nate describes coming back in the morning to work he did not ask for: features he did not want, things he cared about left half-done, and a direction he gave earlier that turned out to be ambiguous.
His clearest example is his own research project. Codex (OpenAI’s coding agent) found 339 sources and wrote more than 1,000 questions. He told it to keep going, and an agent later got stuck repeating work while syncing files. By then his goal had changed: he wanted the 50 most valuable answers with stronger evidence, not a pile of questions. He stopped the run and gave the next agent a short note instead.
As he puts it, this was not a data problem. The research existed. The assignment was badly structured, and what he learned during the run never reached the next agent. The result is paying twice: once in tokens for the run, and again in your own time fixing it.
💡 Tip: Before any long run, write down whether you are in a discovery phase (explore widely) or a refinement phase (narrow down to what matters). Nate says mixing the two was a big part of his problem.
What is the “right context” for long-running AI agents?
Nate splits useful context into four parts:
| Type of context | Example | Why agents need it |
|---|---|---|
| Facts | Your price list, product specs, research sources | The raw material |
| Decisions made along the way | “We agreed the new price is £450, not £395” | Stops the agent following an old choice |
| Examples you developed | A finished proposal you are happy with | Shows the standard you expect |
| Instructions that evolve | “From now on, lead with the 50 strongest answers” | Keeps the agent up to date as you change your mind |
He notes that AI labs already ask new staff to “ask Codex” or “ask Claude” to get up to speed on a codebase. Agents learn the same way: from a record of how a project has evolved, not from a one-off snapshot of your opinion.
What does “treat project information like code” mean?
It means keeping your project knowledge in one organised place where agents can find and read it, with instructions, checks for common mistakes and current decisions stored alongside the work, just as code lives in a repository.
Nate’s non-technical example is a client proposal. You have agreed a new offer and price, but an AI uses an old proposal as its template. The draft looks great and quotes the wrong price. These version mix-ups creep in whenever information is scattered.
His reasoning is that today’s models are heavily trained on code, so files and folders laid out like a project repository are easy for them to navigate. It also helps when several people use different AI tools: if everyone points at the same organised source, it does not matter which model they use.
We have two practical guides for this: How to Keep a Decision Log Your AI Agents Will Actually Follow and How to Stop AI Using an Old Version of Your Document.
Why should skills be built for the team, not for you?
Skills are saved instructions an AI can follow for a particular kind of task. Nate’s view is that most people treat skills as personal superpowers, and that this causes trouble at team level: everyone writes slightly different home-made versions that may not even point to the same data.
- Keep skills in the shared knowledge base, not on individual laptops.
- Write them for the job, not the person: “how we write proposals”, “how we prepare decks”, usable by anyone with any AI tool.
- Use skills to manage people steps too. For example, a skill that tells the agent to ask a human for an edit pass whenever a new version appears.
He is blunt about “skill theatre”: people showing off personal setups instead of simpler systems that put data in one place. And he stresses that you still own the output. “The AI wrote it” is not an excuse to a client.
If your own skills folder has got out of hand, our Claude skills clean-up guide helps you decide what to keep.
Try this today: list the three things you explained to an AI more than once this week. Each one is a candidate for a saved instruction or a line in a shared decision log.
How do roles and version rules stop collisions?
When the knowledge base is the centre of the system, you can write down what each role’s agent is allowed to do: what a project manager’s agent can change, what an engineer’s agent can change and what a contractor’s agent can only read. Nate is clear that a simple rules file is not a full security solution. Proper permissions and guardrails matter, but they are not affordable or available to everyone, and a written structure gets you most of the way while humans oversee the rest.
For collisions (two people or agents editing the same thing), he recommends what engineers call separation of concerns: each piece of work gets its own page or folder, and new versions are made as copies rather than edits over the old one. In his example, the agent starts deck version 15 as a fresh copy instead of overwriting version 14, then tells the next person when it is ready for review.
⚠️ Warning: A written “rules for agents” file only guides behaviour. If an agent has access to delete or send something, assume it can. Limit real access for anything that matters, such as payments or client emails.
How do you know it is working?
Nate thinks “time saved” is too easy a measure. Better questions:
- Are you interrupted less by things you do not care about?
- Are there fewer collisions and overwritten files?
- Are you explaining yourself less?
- Are the questions your agents bring back more useful?
One test stood out: if your agent never asks you anything, that is a warning sign. It usually means you are driving every detail yourself and are probably overstretched.
How can you start on your own this week?
You do not need a company-wide system to start. Nate’s suggestion for individuals:
- Pick one job you keep explaining and correcting, such as weekly reports or client proposals.
- Write down the current facts and decisions for that job in one document.
- Add saved instructions: what good looks like, plus one example you are happy with.
- Open a fresh chat, give it only that material and run the job again.
- Compare the result. Did you have to repeat yourself less? Update the document with anything new you learned.
If you have already tried our AI handoff file approach, this is the next step: the file becomes a living record you keep, not a one-off note.
Nate also offers a paid “working context starter kit” for his Substack subscribers. We have not reviewed it; the steps above work without it.
🛠️ Practical guides
Ready to put this into practice? These step-by-step guides answer two common follow-up questions:
- How to Keep a Decision Log Your AI Agents Will Actually Follow — a simple, dated record of decisions that stops agents following yesterday’s choices.
- How to Stop AI Using an Old Version of Your Document — folder and naming rules so your AI always works from the current draft, price and offer.
Watch: the source video
What this video covers: why long AI agent runs go wrong, how to give agents current decisions, examples and instructions, and how teams can share skills, roles and version rules.
Video: Nate B Jones (AI News & Strategy Daily), “Anthropic Ran 1,000 AI Agents For 8 Days. Yours Still Needs The Same Thing Explained Again.”, published 20 November 2026. Not sponsored; Nate mentions his own paid Substack starter kit. This summary and the opinions in it are our own.
Next step: choose one task you re-explain every week, write its current decisions and one good example into a single document, and rerun it in a fresh chat. Keep the document updated every time you change your mind.
Frequently asked questions
What is a long-running AI agent?
An AI agent set up to keep working on a task for hours or days with little supervision, for example writing, testing and reviewing work through many smaller sub-agents.
Did Anthropic really run 1,000 AI agents for eight days?
That is what Anthropic reported, as shown in Nate’s video: Claude coordinated more than 1,000 sub-agents over eight days to build a prototype operating system. It is a lab experiment, not an independent test.
Why does my AI keep forgetting decisions I made?
Usually because the decision only exists in an old chat or in your head. Write it into a shared, dated document the agent reads every time.
Do I need to know how to code to treat information like code?
No. It simply means organised folders, clear file names, a decision log and saved instructions in one place that your AI tools can read.
Is a rules file enough to control what AI agents can do?
No. It guides behaviour, but real permissions and access limits are what stop an agent doing something harmful. Use both for important work.
Related posts
- Give AI Your Failed Attempts: How Fable 5.2 Got It Right First Time
- AI Agents and Productivity Theater: 4 Principles to Make Them Do Real Work
- OpenAI Outgrew Git: What Happens When AI Agents Write Code Too Fast
