From Human-in-the-Loop to Out-of-the-Loop: A Hands-On Guide to Automated News Curation with Durable Agents

As AI-generated content expands at an exponential rate, the scarcest resource for engineers is no longer code — it's attention. In his video, IndieDevDan demonstrates a system called Durable News Agent: rather than waiting for human instructions, it automatically fetches, filters, ranks, and presents news once per minute, with humans stepping in only at key points to give feedback. Behind this lies a more important proposition — engineers are migrating from "human-in-the-loop" to "human-out-of-the-loop," and proactive agents are the critical intermediate stop in that migration.

Noise, Facts, and Signals: A Three-Layer Information Filter

IndieDevDan divides the incoming flood of information into three categories: hype, fact, and signal. Hype is driven by unfounded excitement — the topic itself is eye-catching enough; facts are objectively true statements but not necessarily immediately actionable; signals are information you can use right now. He illustrates the distinction with a concrete example: OpenAI announcing a large batch of mathematical proofs is a fact, but for ordinary engineers it isn't yet actionable; whereas Gemini 4 Argon becoming available through an API is a signal you can wire into code immediately.

This classification framework defines the entire system's design goal: not to aggregate more news, but to filter out the "actionable" parts. As he says in the video: "My agent pulled it for me, I didn't have to go find it."

The Durable Agent Architecture: Client-Server Separation and Durable Tasks

The core of the system isn't a flashy interface but a layered architecture. At the bottom is a SQLite database, above which sits the durable task capability provided by Pi Durable, wrapped further up as an API, with "thin clients" — browser, terminal TUI, CLI, and Cron — on the outermost layer. The actual agent runs on an M4 Mac mini or an exe.dev cloud sandbox, and all clients are simply interfaces that connect to it.

This separation produces an intuitive experience: the news feed seen in the browser stays in real-time sync with terminal query results. In the video, he demonstrates asking the terminal "what's the last entry you added," and the answer matches the browser card. More importantly, Cron triggers a task every minute, so even when the human leaves the keyboard, collection, deduplication, and ranking continue to happen. He summarizes the definition of a proactive agent in one sentence: "A proactive agent equals a durable agent inside a sandbox plus a trigger."

Durable Task and Pi Durable

Traditional scripts or API services lose the state of in-progress tasks when a process crashes, a machine reboots, or the network drops, requiring a restart from scratch. The core idea of durable task frameworks (such as Temporal, Restate, and the Pi Durable mentioned here) is to write the execution state of every step to durable storage, so that tasks can resume from a checkpoint after a failure and the same task won't be triggered twice. Pi Durable plays the "task orchestration layer" here: it schedules the once-per-minute scan task, records the progress and intermediate results of each scan, and retries on exceptions. Precisely because task state lives in SQLite rather than in memory, the agent on the M4 Mac mini or cloud sandbox can run persistently over the long term, and multiple thin clients can read a consistent, up-to-date state. Without this layer, "still working after you leave the keyboard" would be impossible.

Keeping Expensive Model Calls in Check with a Cheap Classifier

Throughout the pipeline, a classifier called Jev handles a large share of the "coarse screening." Each news scan performs: collection, gating, deduplication, and ranking, after which the durable agent decides which candidates to render. Jev is used to judge relevance, identify duplicates, check factual consistency, and even help generate presentation content. According to the video, a single classification call takes under half a second and costs very little.

The significance of this layer lies in token economics. Even with a cheap underlying model like Luna, once-per-minute calls still accumulate considerable token and compute overhead. Putting Jev up front for gating lets the expensive language model handle only content that could genuinely become a signal, which is how the system keeps costs under control while running continuously. He mentions keeping a constant eye on tokenomics to ensure he "doesn't go broke generating value."

Gating and Cascade Classification

Gating is a classic technique in information retrieval and recommender systems: before sending candidates into an expensive processing stage, apply low-cost rules or a small model for a coarse pass, letting through only the promising few. It aligns with the idea of a "cascade classifier" — most samples are quickly eliminated at the first stage, and compute is concentrated on the small number of hard cases.

In this system, Jev is that first stage: it judges relevance, identifies duplicates, and checks factual consistency, keeping a flood of noise at bay; only candidates that pass the gate are handed to the underlying language model for deep processing and presentation. Because scanning runs as often as once per minute, even at a very low per-call cost, the daily cumulative call volume is substantial — making gating the key valve for controlling token spend. Two things matter in the design: the gate's recall can't be too low (or signals get killed by mistake), and the classifier's decision criteria must be able to update with user feedback.

The Data Flywheel: Upvotes, Downvotes, and Dynamic Weights

The most instructive product design choice in this tool is writing user feedback directly back into the ranking algorithm. In the video, he upvotes a piece of news about the Gemini 4 Argon release, and the system immediately shows Jev's classification: roughly 66% hype, with the rest being fact and signal — the reasoning being that model labs naturally exaggerate their announcements. He then issues a conversational instruction: "increase the weight of Gemini, and add the keyword if it doesn't exist." The agent reads the settings file, raises the Gemini keyword weight from 1.2 to 1.3, and all subsequent scans carry that preference forward.

The settings panel also maintains a keyword list and news source links, covering commonly used sources such as Hacker News, Latent Space, Claude Code, Anthropic, OpenAI, and Simon Willison. Users can continuously shape the information flow by upvoting, downvoting, adding weight, and deleting cards. This is the data flywheel he keeps emphasizing: user input is absorbed by the agent, which in turn improves the product itself.

A Purpose-Built Toolset, Not a General-Purpose Chatbot

Durable News Agent has its own toolset: run a news scan, list candidates, read entries, search the web, fetch URLs, research entries, classify with Jev, present news, present a timeline, and ask about the user's tastes. These tools were built using an "in-the-loop agent" and then baked into an "out-of-the-loop agent" that calls them automatically. His metaphor is "using a system to build a system" — briefly stepping into the loop so the system can work outside the loop over the long term.

What sets it apart from a general-purpose chatbot is the boundary of its actions. It doesn't read files or modify code; it does one thing — news curation — so every tool can be deeply optimized for that scenario. The video shows two instances running in parallel, one in the cloud and one local: the feed on the M4 is more fine-grained, while the instance on the exe.dev sandbox follows a different set of topics and proactively asks the user questions, forming a two-way prompting mechanism.

In-the-Loop, On-the-Loop, Out-of-the-Loop: A New Yardstick for Engineering Capability

The point of the whole demo isn't the tool itself but a mental model: excellent engineers are migrating from "human-in-the-loop" (turn-by-turn prompting) to "human-on-the-loop" (periodic review and feedback), and ultimately to "human-out-of-the-loop" (the system runs autonomously, with intervention on demand). He calls this migration the core value of proactive agents and considers it a direct measure of agentic engineering capability — not how many prompts you can write, but how many autonomous threads are continuously producing for you.

Faced with the claim that "software engineering has been solved," his response is quite direct: code has become cheap and copyable, and what's truly scarce is taste, judgment, and the ability to architect unique systems. Agents are just a new tool. "Don't let it scare you into not shipping." The value of 15 years of engineering experience hasn't disappeared — only the way it's applied has changed.

Human-in-the-loop / on-the-loop / out-of-the-loop

This set of terms comes from automation and human-computer interaction research and describes where humans sit within an automated system. "Human-in-the-loop" means the human participates in every decision cycle, with the system waiting for confirmation step by step, as in turn-by-turn conversational prompting; "human-on-the-loop" means the system runs autonomously while the human periodically reviews results and corrects as needed, acting like a supervisor; "human-out-of-the-loop" means the system operates fully autonomously, with the human stepping in on demand only at anomalies or key points.

Automation research generally notes that the risk of being out-of-the-loop is that errors are hard to catch in time, which calls for good observability, feedback channels, and rollback mechanisms. Translated to agentic engineering, this means: the precondition for handing tasks to an out-of-the-loop agent is first designing the feedback entry points (upvote, weighting, card deletion) and state visibility (timeline, candidate list) — otherwise "autonomous" turns into "out of control."

Practical Takeaways

If you want to reproduce a similar system, start with three minimal steps: first, define your "signal" criteria and sort information into hype, fact, and action items; then split collection and filtering into a cheap classification layer and an expensive generation layer to control the cost of continuous operation; finally, leave feedback entry points (upvote, weighting, card deletion) for users (or yourself) so that ranking weights converge gradually with use. The value of a Durable Agent isn't a single impressive output, but that it keeps working for you after you leave the keyboard.

As shown at the end of the video, the system has been running continuously for over a day and has picked up items such as Anthropic's "code merge volume up nearly tenfold since May," correctly flagged as predominantly hype. As model inference costs continue to fall, the feasibility of such always-on agents will only increase — and how to design the division of labor between them and humans will be the core engineering question of the next phase.

One-line Summary

Proactive agents autonomously curate news via durable execution plus triggers, pushing engineers from human-in-the-loop to out-of-the-loop.

Paragraph Summary

The article introduces the Durable News Agent demonstrated by IndieDevDan: an always-on agent that automatically fetches, filters, ranks, and presents news once per minute. The system sorts information into hype, fact, and signal, keeping only actionable signals; architecturally it uses SQLite plus Pi Durable durable tasks, with an API separated from thin clients, and the agent running persistently in a sandbox triggered by Cron. The pipeline first gates with a cheap classifier, Jev, before calling expensive models to control the token cost of continuous operation. Upvotes, downvotes, and keyword weight adjustments form a data flywheel that lets ranking converge with feedback. From this, the author proposes the in-the-loop / on-the-loop / out-of-the-loop yardstick, emphasizing that with code now cheap, what's truly scarce is taste and architectural ability.