Low-poly robot walking a long path from night into morning carrying a glowing folder, representing a long-running AI agent staying on track

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.

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:

WhoWhat they reportedDate shown
OpenAISeveral continuous sessions ran for hundreds of hours, finding and fixing edge cases in its new code-management system2 Nov 2026
AnthropicClaude coordinated more than 1,000 sub-agents working around the clock for eight days to build a prototype operating system that boots on a laptop9 Nov 2026
GoogleInternal teams have seen Gemini 4 Carbon run for days on hard engineering problems10 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 contextExampleWhy agents need it
FactsYour price list, product specs, research sourcesThe 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 developedA finished proposal you are happy withShows 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.

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:

  1. Pick one job you keep explaining and correcting, such as weekly reports or client proposals.
  2. Write down the current facts and decisions for that job in one document.
  3. Add saved instructions: what good looks like, plus one example you are happy with.
  4. Open a fresh chat, give it only that material and run the job again.
  5. 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:

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.

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.

author avatar
Garry Knight
I'm Garry Knight, the person behind Prodify Digital. I write about email list building, email marketing, SEO, AI search and the tools that connect them. My aim is to make online marketing easier to understand, so creators and small business owners can make informed decisions about building an audience and keeping people engaged. Here you'll find straightforward guides and product reviews that explain what something does, where it fits and which limitations matter. The focus is on clear explanations and useful next steps—not hype, shortcuts or promises of easy earnings.

Leave a Reply