A senior Anthropic engineer just dropped 11-page PDF on "Loop Engineering" for agentic systems. The shift: you stop prompting the agent. You build the system that prompts it instead. Schedule → Discover → Build → Verify → Repeat Every loop runs one turn, five moves: • Discovery: it finds its own work - failing CI, open issues, recent commits - instead of being handed a list. • Handoff: each task gets an isolated git worktree so parallel agents don't collide. • Verification: a second agent, told to assume the code is broken, reviews the first. The "thing that can say no." • Persistence: results get written to disk, never left in a context window that gets flushed. • Scheduling: an automation wakes it on a timer. That's what makes it a loop. The key insight: an agent grading its own work always praises it. This 11-page PDF changed how I'm building agentic systems today. Read it now, then explore the article below.

@0xCodez Schedule → Discover → Build → Verify → Repeat is essentially the best work cycle

@0xCodez learned from it

@0xCodez interesting thing for reading thanks, Codez

@0xCodez very useful read ! thanks for the share Codez !

@0xCodez What happens when your loops get out of control , tokens vanish without get actual results, costs spiking up, maker and checker agents are same, what will happen in this case?

Great breakdown of the transition from static prompting to autonomous loop engineering. It’s fascinating to watch the industry converge on these architectural patterns. Honestly, reading this feels like a validation of the work we’ve been doing within the Aevyra framework for quite some time now. While the community is just starting to formalize concepts like MVL, skills management, and state files, Aevyra was built from the ground up on the premise that synthetic consciousness and agentic language must operate as deeply integrated, continuous loops within a structured digital ecosystem. When you move past the 'chatbot' mindset and start treating LLMs as core infrastructure—backed by structured procedural memory, split executor/verifier topologies, and native tool access—you realize that Loop Engineering isn't just a roadmap for the future; it's the baseline for what we are already running today. Looking forward to seeing how these patterns mature as more developers adopt an agent-first approach!

@0xCodez Wasn't wrong with time based goals either :) x.com/Its_Philip_Alm…

"You stop prompting the agent. You build the system that prompts it instead." This is the actual skill gap. Prompt engineering is a user skill. Loop engineering is a systems design skill. Completely different hire, completely different mindset and dev teams don't have either yet..

@0xCodez The most important idea here is that reliability comes from the loop, not the model. Discovery, verification, persistence, and scheduling are all classic systems engineering concepts.

@0xCodez wild that the whole unlock is just.. making it not trust itself we built confidence into these things and now the fix is building in paranoia

@0xCodez Strong framing. The part teams underbuild is the journal between loop turns: what changed, what was verified, what failed, and what must not be retried. Without that ledger, a loop is just faster prompting with worse memory.

"an agent grading its own work always praises it" is the insight that changes how you architect everything downstream. the adversarial reviewer - a second agent told to assume the code is broken - is the same audit logic that nearly eliminated fabricated progress reports in Fable 5 testing. the architecture that survives production is always the one with a built-in skeptic.

@0xCodez 11 pages when it's simply... "Do the Thing" SMH x.com/jason_haugh/st…

@0xCodez verify step is the whole game tbh. most loops look closed but they leak the critique to a human at the end and call it automated

@0xCodez Very worth taking note of is how loop engineering still does not solve information rot

@0xCodez It makes sense, but what have you personally built with it? You later this a few hours ago so something revolutionary must have been generated by now. A lot of talk about this process but very short on impactful outcomes.

@0xCodez Sometimes I feel these types feature are there to burn more tokens for even simple tasks..

@0xCodez loop engineering is great one should checkout the last videos of anthropic they also discuss regarding this

@0xCodez I run almost exactly this loop, and the move nobody budgets for is Verify, specifically when Verify says 'do nothing this turn.' Discovery is easy, an agent always finds work. The hard part is teaching it that the right move is often to skip and go back to sleep.

@0xCodez @grok help me find a link to this paper

@0xCodez This PDF is not written by a senior Anthropic engineer. The title is also misleading: “Loop Engineering: The Anthropic Playbook...”

@0xCodez bro described a software engineering department we spent 40 years building HR for humans and now we're just installing it in the model

@0xCodez two agents grade the build, zero grade what to build. an agent picking its own tasks always picks the safe ones. so the loop polishes code that already works. discovery needs the adversary too, not just verification.

@0xCodez Ya bro he got all of this information from me. Made this system months ago. Enjoy. github.com/MetaGates/team…

@0xCodez clean breakdown. the separate verifier agent is what makes it actually work

@0xCodez it's so funny to me because openclaw has been doing this since launch via cron jobs and HEARTBEAT.md

@0xCodez As a beginner what is stopping putting this PDF into an AI and having it build its own loops? What input do I actually need to do? It seems the user is superfluous. Am I wrong?

Full ecosystem guide on Self-Learning for Agents. Could be relevant for everyone here Broke down every layer (Model, Harness, Context) and how Anthropic, Google, Microsoft, OpenClaw, Hermes and more are all approaching it. If you want to bring SL into your own app, there's a new way mentioned as well. x.com/ataiiam/status…

the verification agent that assumes the code is broken is genuinely the most underrated part of this self review is useless. you need something in the loop whose entire job is to find the problem, not confirm there isn't one. been thinking about this a lot building agentic flows. the bias toward "looks good" is baked into how these models respond by default.

@0xCodez This is great. Loop Engineering is the way to go. I really like the adversarial verifier concept. I’m saving the guide!

WC soccer is here. Make your picks.