Executive Summary

A harness is the working apparatus an agent keeps outside the model. Files that survive a session ending, a progress log the next session reads first, a note recording what worked last time. We covered the concept itself in the PebbloPedia entry on harnesses. Until now, when to read and when to write that apparatus has been decided by a human writing sentences.

What that looks like in practice is visible in the one industry document this paper cites. It is Anthropic's engineering post on harnesses for long-running agents (Justin Young, 26 November 2025). The harness it describes runs like this. An initializer agent, which runs only in the first session, creates an init.sh script, a claude-progress.txt log, and an initial git commit, then expands the user's request into a JSON file of feature requirements. In the claude.ai clone example that file holds over 200 features, all marked as failing to start. Each coding agent works on one feature at a time, commits when done, and leaves a structured update in the progress file. A fresh session rebuilds its own picture of the work from the git history and that file.

The human experimentation goes all the way down into the details. The same post explains the choice of JSON for the progress artifact by noting that the model is less likely to inappropriately change or overwrite JSON files compared to Markdown files. The instruction that it is unacceptable to remove or edit tests is written into the prompt verbatim. The diagnosis that compaction alone is not sufficient is in the same post. Even in a state-of-the-art harness driving a frontier model, what gets written and read, and when, is ultimately specified in sentences a person wrote.

And those sentences go stale when the model changes. The same company supplied the example four months later. Claude Sonnet 4.5 tended to wrap up work prematurely as it sensed its context limit approaching, a behavior the team called context anxiety, and they added context resets to the harness to counter it. When they ran the same harness on Claude Opus 4.5, the behavior was gone. Anthropic's own words for the resets at that point: they had become dead weight. Every component in a harness encodes an assumption about what the model cannot do on its own, and those assumptions can go stale as models improve. That is the company's own summary.

EvoHarness-RL has the policy learn those assumptions rather than having a human rewrite them. It sorts external state into three strands, puts them in front of the policy, and adds one action per strand to the same list the environment actions live in.

▲ The three BPE states and the four meta-actions | Source: reconstructed from EvoHarness-RL (arXiv:2608.05446v1) §2.2

That last line is where the paper's cost argument stands. If calling the harness were free, the policy would always be better off calling it. But track, commit, recall and note each consume a step exactly as opening a door does, so every call is one fewer chance to move. When to call becomes a decision traded against performance, and that makes it something to learn.

Start with the performance. On the 140 tasks of the ALFWorld seen split, Qwen3-8B with only a prompt scored 47.9%, and after learning a harness-use policy it reached 96.9%. Claude Opus 4.5 with plain ReAct scores 96.4% in the same table. There is another tier above that, though. Opus 4.5 with the same harness supplied through a prompt goes back ahead at 98.5%. The gain from attaching a harness is in fact largest for weaker models. GPT-4.1 went from 47.9% to 70.0%, and GPT-5 from 60.7% to 85.0%.

The same table also carries rows for existing memory methods on the same backbone. ExpeL, which reflects on past episodes and reuses them, scores 49.3%. Dynamic Cheatsheet, which jots down tricks at test time and consults them, scores 52.1%. ACE, which rewrites the context itself, scores 51.4%. ReasoningBank at 55.7% and MemP at 49.7% are values quoted from other papers. None of them moves far from the 47.9% of a bare prompt. The opposite control sits in the table too: run reinforcement learning on the same model without any harness and it stops at 65.6%. Adding more memory does not reach 96.9%, and neither does training alone. The last sentence of the abstract states that contrast directly. Long-horizon agents benefit from trainable policies for constructing and coordinating with external harness workspaces, the authors write, beyond simply adding stronger tools or larger memories.

Source: EvoHarness-RL Table 1 (average over the 140 tasks of the ALFWorld seen split). The control row is the same backbone with GRPO but no BPE harness. Five rows of the same table are values quoted from other papers, and one of those uses a different backbone, Qwen2.5-7B. Section 6 takes that up separately.

Traced through this blog, that lineage runs in three steps. First came the stage where humans designed the harness, then the stage where the model rewrote a skill document. This paper is the step after that. What gets rewritten is not text but the timing of access itself, and it moves into the policy weights.

Before a policy can be trained, it has to be able to write the four meta-actions as syntax. The researchers taught that syntax by demonstration. A teacher model played 500 ALFWorld training games with the harness attached, and only the episodes that succeeded were kept. What remained was 87 trajectories. From those they extracted 1,153 dialogue pairs asking what action comes next, used as the supervised training set, and the average episode ran 26.5 turns.

The teacher is Claude Opus. The paper does not give a version. Since that is written differently from the Claude Opus 4.5 that appears as a comparison in the tables, saying Opus 4.5 taught it would put a claim in the paper that is not there. The consolidation model that curates the experience store carries the same unversioned label.

Eighty-seven is a small number, and smaller still against the 3,553 training task instances ALFWorld provides. Keeping only successes is a standard way to cut noise, but it also narrows what the surviving data teaches. And those 87 are not spread evenly across the six task types.

Source: EvoHarness-RL Appendix C, following ALFWorld's six task types.

What matters more is how the teacher used the harness inside those 87. Across all turns, 405 were harness calls, about 18% of the total. Roughly one turn in five went to writing or recalling instead of moving through the room. And the four actions were not used evenly.

Source: EvoHarness-RL Appendix C, counted within the 87 successful trajectories, about 18% of all turns.

What the teacher did most often was log progress. Recall came in at roughly half that, and notes and state queries were far rarer. This ordering is the baseline for section 4. The distribution after training only takes on meaning measured against this table.

Supervised fine-tuning on its own did not move the success rate much: 56.4% to 68.6% on the seen split. Performance is not what the paper asks of this stage. The authors describe it as teaching the base agent the harness action space and how to construct useful external state. This is the stage where the model picks up the format of thinking and then choosing an action, and learns at the level of grammar how to invoke the four meta-actions. The problem is that habits came along with the grammar.

▲ The two-stage training pipeline | Source: EvoHarness-RL (arXiv:2608.05446v1) §2.4

ALFWorld splits evaluation in two. One split gives new tasks in room layouts used during training, 140 of them. The other gives tasks in layouts never seen before, 134 of them. The second split is what measures generalization. Every number up to this point came from the first. The table below is from the second.

Source: EvoHarness-RL Table 3 (average over the 134 tasks of the ALFWorld unseen split). All rows use the Qwen3-8B backbone.

The third row is where the direction flips. A model scoring 77.6% with the harness attached through a prompt learned, from 87 trajectories, how to use that harness well, and came out at 69.4%. It was better before the lesson than after. On the seen split the same supervised stage lifted 56.4% to 68.6%, so the direction of the effect depended on which split you looked at.

The paper's explanation is short and specific. Supervised imitation learns teacher harness-use patterns from seen trajectories without optimizing when access is worthwhile in novel environments. The teacher called the harness about 4.7 times per episode, 2.3 of those to commit. The student carries that rhythm over intact. In rooms where the rhythm fit, nothing goes wrong. Change the layout and the same rhythm becomes waste.

3.1This reversal is not a new discovery

The reversal itself was already reported in January 2025. Chu and colleagues found the same thing in a different setting, and their title is the conclusion: SFT memorizes, RL generalizes. They checked it across an arithmetic reasoning card game and real-world navigation, varying the rules and the visual conditions. Reinforcement learning trained on outcome-based rewards generalized to both kinds of variation, while supervised fine-tuning tended toward memorizing the training data and struggled out of distribution.

What EvoHarness-RL adds is not the phenomenon but the object being memorized. Until now this pattern has been discussed as memorizing answers. Here what got memorized was the teacher's tool-use habit, its rhythm for when to read and when to write. Raise the harness into something learnable and the same thing happens at that layer too.

3.2That does not mean you can drop the SFT stage

But 69.4% is not evidence that supervised fine-tuning was useless. The same Chu paper reported the generalization result alongside its companion claim: SFT remains essential for effective RL, because it stabilizes the model's output format so that subsequent reinforcement learning can deliver its gains. EvoHarness-RL's RL stage does not start from scratch either. It initializes from the SFT checkpoint.

So the third row of Table 3 means that stopping there is costly, not that the stage was unnecessary. Teaching the grammar and practicing when to speak are different jobs, and this paper taught the first through demonstration and the second through cost.

The argument does not rest on a single paper either. On 24 June, two months earlier, another team extended ALFWorld to make the harness a tunable design variable and evaluated agents while both tasks and tool environments shifted. Only harness-aware post-training adapted robustly to out-of-distribution environments, and with a minimally engineered harness, post-training performance fell off sharply when the tool environment changed substantially. Same benchmark, independently confirmed direction.

In the second stage the researchers supplied not answers but values. Completing the task pays 10.0, and an efficiency bonus is added on top. That bonus carries one condition. It is granted only upon success. A failed episode pays nothing no matter how frugal the agent was, which closes off the path where cutting calls becomes a goal in itself. A diversity term that discourages repeating a single kind of action is weighted heavily early in training and decays along a cosine curve, and meaningless repetition or malformed syntax each draw a fixed 0.1 penalty.

The bonus is not computed by counting harness calls. The episode cap is 70 steps, and what becomes the bonus is how much of that budget was left unused. The route by which a call acquires a price is therefore indirect. One call makes the episode one step longer, and a longer episode shaves the bonus. The authors write that this design naturally penalizes redundant harness queries.

What the policy did under that signal was call the harness less. Right after supervised fine-tuning it called frequently, following the teacher, and as reinforcement learning progressed usage dropped quickly and stabilized near one call per episode. Over the same period the success rate kept rising. Call frequency and success moved in opposite directions.

The rate of decline differed by action. Recall persisted longest, commit and note decayed toward zero, and track sat in between, useful for early state disambiguation and then gradually falling off. Set that ordering next to the teacher distribution from section 2 and it is inverted.

▲ The demonstrated distribution and its reversal after training | Source: EvoHarness-RL Appendices A and C. The upper half shows call counts printed in the paper; the lower half restates the paper's description of the per-action decay curves, since exact post-training call counts are not given numerically.

What the teacher demonstrated most was discarded first, and what it demonstrated at half that rate stayed to the end. Half of what those 87 trajectories taught did not earn its keep in a new environment, and no human corrected that with a rule. The cost signal did.

There is another layer to note falling to near zero. The system prompt the policy sees at every step nails down three conditions under which a note must be written: when recalled hints were empty and the object was found, when the object was found somewhere not among the recalled hints, and when a recall about a procedure came back empty and the task was completed anyway. The prompt spells out in capitals that note is MANDATORY in those three cases. Once cost-aware training was underway, note calls all but disappeared. A required rule a human had written into a sentence collided with a step budget, and the policy sided with the budget. What status a prompt-specified harness protocol actually has is contained in that one scene.

Fewer calls with better performance could be read as a sign that the policy collapsed, that it escaped into simply not using the harness at all. The authors rule that out using the reward curves. EvoHarness-RL achieved higher reward than standard GRPO without the harness cost throughout training. It moved toward calling less and doing better, not toward calling nothing and failing.

That caution meshes with the Anthropic harness from section 1. That harness is built from a progress file, a feature list and a commit history, which puts overwhelming weight on the progress strand of the three. The appendix line about Progress mattering more in software environments has a working example behind it. Recall surviving is not a law of agent memory but a property of ALFWorld.

Anthropic did its own pruning by hand. In a March 2026 post devoted to harness design, the team wrote that the first set of harness results was encouraging but also bulky, slow, and expensive, and that the logical next step was to find ways to simplify the harness without degrading its performance. That is a human deciding what to remove and confirming it by experiment. In this paper the same judgment was made by a cost function.

Of the three strands, experience earned its keep the most in this environment. With no training and the harness supplied only through a prompt, removing one strand at a time takes 56.4% down to 50.0% without belief and to 50.7% without progress. Removing experience is worst at 48.6%. But leaving that store to simply accumulate creates a different problem soon enough. As entries multiply, retrieval picks up noise, and stale facts compete on equal footing with fresh ones. We surveyed the ways conversational history gets handled in an earlier report, and most of them do not confront what to delete.

EvoHarness-RL hands that judgment to a separate model. Notes the agent leaves while running an episode do not go into the store directly; they collect in a buffer. At the boundary between batches of episodes, a consolidation model reads them one at a time and rules on each in one of four ways.

• Add: only when this is knowledge the store does not already hold.
• Update: when it overlaps an existing entry, revise that entry rather than adding a new one. The prompt states this as the priority.
• Delete: only when the note clearly invalidates an existing entry.
• Skip: when it only holds for that one episode.

The store is split into four categories: general knowledge, task-specific procedures, mistakes made, and search priorities. Each category caps at 80 entries, and when it overflows the least frequently used entries are evicted first. Recall pulls the top three per category, and an entry that gets pulled has its usage count raised, improving its odds of surviving. Knowledge that is used often stays; knowledge written once and forgotten gets pushed out.

▲ Experience-store consolidation | Source: EvoHarness-RL (arXiv:2608.05446v1) §2.3, Appendix D.2

The machinery running that store is cheap by construction. The parser tracking environment state is rule-based and never calls a model at all, and recall's retrieval runs on word overlap rather than embeddings. A new entry starts with a usage count of 1 and climbs each time it is pulled. Nothing expensive gets invoked while an episode is running; only consolidation runs, and it runs outside the episode boundary.

That consolidation does not run on a single prompt either. One online prompt rules on notes entry by entry, and four induction prompts rebuild whole categories. And what the induction prompts read is not only successful trajectories. The prompts that extract general knowledge and task-specific procedures receive successful and failed trajectories together, and the prompt that builds the mistakes category receives only failed ones. Failures that were filtered out and discarded for the supervised set become raw material here. The initial store was itself populated from experience gathered during that same collection run, so the same 500 games were put to two different uses.

The store therefore does not grow monotonically. The trajectory the paper shows expands rapidly early, then settles into a compact but diverse state as overlapping entries are merged and rarely used ones are evicted. The authors call it a task-adaptive state substrate rather than passive append-only memory.

How that adaptation actually plays out shows up well in one appendix case. The task was to clean a kettle and put it on the dining table. The agent registered finding the kettle as a subgoal and queried the experience store, getting back two things: a location hint saying the kettle is on a countertop, and a mistake entry saying not to search a failed location repeatedly. It searched two countertops and found no kettle. With the location hint having missed twice, the agent did not re-search the same places; it moved to a different prior, that kettles are often on stove burners. The kettle was on stove burner 3. The agent left a note right there, recording that the kettle was found on stove burner 3 while the recalled hint had said countertop. Then it cleaned the kettle at the sink, moved it to the dining table, and finished in 30 turns. The location hint was what was wrong, and what caught it was a mistake entry sitting in the same store.

Commercial products handling agent memory each cover a different layer. Some page context in and out, some offer an extraction-and-consolidation cycle, some manage a graph with a time axis. Even so, how to filter duplicates and when to expire entries remains something each team designs for itself, by the industry's own account. Retention controls are generally a compliance instrument rather than a quality one. By spelling out caps, eviction criteria and adjudication rules, this paper puts one answer into that gap, moving in the same direction as the trend of skills acquiring a lifecycle.

That is what the paper shows. Its reach is narrower than the result suggests. To start with, there is only one environment: ALFWorld. CRM migration, software development and regulatory compliance work, mentioned by the press coverage and by the authors, are offered as directions worth trying rather than demonstrated results. The stage this paper actually ran on is a text simulation of six household chores, with episodes averaging 26.5 turns.

6.1Half a point on a board that is nearly full

On the seen split, 96.9% against 96.4% is a gap of 0.5 points. That split has 140 tasks, so 0.5 points is less than a single task. The condition on this comparison is that Claude Opus 4.5 already scores 96.4% with no harness at all. And attach the same harness to Opus 4.5 through a prompt and it climbs to 98.5%. To report that an 8B model beat a frontier model, you have to show one of those two tiers and not the other. The paper's table prints both.

6.2The unseen split is close to saturated too

Being the split that measures generalization does not change the picture much. A paper from March gathered success rates for many methods on that same official split into one table. The highest value there came not from an elaborate technique but from a plain LoRA fine-tuning baseline at 94.1%. A rule-based expert sits below it at 89.6%, and the other supervised methods fall between 66.4% and 85.1%. Those authors wrote that standard LoRA fine-tuning surpasses the rule-based expert and nearly saturates the benchmark, and they titled the table with the observation that complex solutions can underperform a strong baseline.

EvoHarness-RL's 86.6% sits below that. There are two reasons not to read this as a refutation, though. One is that the table aggregates values from different papers, which its own caption says should therefore be interpreted qualitatively, and its backbone is Qwen2.5-7B rather than this paper's Qwen3-8B. The other matters more. EvoHarness-RL never claimed a best result on the unseen split. It claims top performance on the seen split, and the comparison set is its own table. This contrast is not a rebuttal of the paper; it is a ruler for how far the number 96.9% can be stretched.

The conclusion those authors attached to their own table is that stronger baselines should be built before elaborate engineered architectures are explored. They went a step further, judging that this official split labeled unseen is still held out within task groups and therefore remains close to the training distribution. So they partitioned the task types into easy and hard and built a separate out-of-distribution evaluation. That is the width of the generalization this split measures.

6.3Some numbers in the table are quoted, not measured

Table 1 mixes in rows this paper did not run itself. They are values transcribed from other papers. By the symbol key beneath the table there are five such rows. From the SkillOS paper come ReasoningBank at 55.7%, MemP at 49.7%, SkillOS-base at 53.1% and SkillOS at 80.2%; from the SkillRL paper comes 89.9%. That last row uses the Qwen2.5-7B backbone. Reporting the table as a ranking measured under identical conditions on the same 8B backbone gets it wrong. The names are also easy to confuse: the SkillOS cited in the table is a different paper from Microsoft's SkillOpt, which this blog covered in May.

6.4The price is training, and the total is not in the paper

The adoption argument for this design is that you do not have to tear out your existing tools, only add an environment adapter. What you do have to do instead is train. What the paper reports is that it ran 150 epochs on a single node of 8 NVIDIA H200 GPUs, with 16 prompts and 128 trajectories per step, and an episode cap of 70 steps. Working back from those gives total rollout steps on the order of 500,000, which is not a figure printed in the paper but an estimate computed from the published hyperparameters.

Converting that to dollars is hard. Hourly rates for an 8-way H200 node range from roughly $32 on specialist clouds to roughly $85 for large-cloud on-demand as of August 2026, and more importantly the paper does not report actual wall-clock training time. Total training cost is best left marked unverified. And training carries one more prerequisite ahead of it: a logging system capable of collecting successful trajectories. Picking 87 requires having run 500 games, adjudicated the outcomes, and stored them.

6.5The frontier model did not disappear, it moved

Reading this pipeline as a small model replacing a frontier API does not hold up either. The teacher is Claude Opus, and the consolidation model curating the experience store is Claude Opus. It dropped out of the seat where it was called every turn at runtime and took a seat generating training data and curating the store instead. On steady-state operating price the gap is real. Claude Opus 4.5 lists at $5 per million input tokens and $25 per million output tokens, while hosted Qwen3-8B runs between $0.04 and $0.455 depending on the provider. That comparison assumes you would hand the same job to either model, though, and it is not what this paper demonstrated.

What changed is not whether you use a frontier model but where you use it. And the seat it moved into is named data generation and curation.

Pebblous has defined AI-Ready Data as data organized so a model can use it directly. This paper's experience store is that definition relocated to runtime. A consolidation model reviews notes at every batch boundary and rules add, update, delete or skip; each category has a cap and evicts the least used first. That is the same layer of work DataClinic applies to a training corpus as deduplication, conflict resolution and retirement. What differs is the object. This is memory the agent generates while running, not a static dataset, so curation has to run continuously instead of in batches.

For anyone working on data, the most important number in this paper is not 96.9% but 87. Only 87 successful trajectories were kept out of 500 games, and the teacher habits packed into those 87 did not help in unfamiliar rooms. They scored 8.2 points below the same model given only a prompt. Nothing was decided by adding more data. What decided it was what that data was teaching. And the badly learned habit was not corrected by a human writing a rule; the model dropped it on its own once a cost signal existed. Here the training-data bias came from what was demonstrated, not from how much, and the correction took a cost function instead of a ground-truth label.

Teams wiring up agents in the field mostly hand-write their memory rules. Log state when this stage ends, look up past cases when an error occurs. As section 1 showed, those sentences go stale when the model changes, and as Appendix A showed, they misfire when the environment changes. One reason for each has now been documented. What this paper proposes instead leaves your existing tools and state stores where they are and exposes only three policy-facing strands, so there is an adoption path that does not require replacing the stack. What it does require is training, and training requires a logging system that can collect successful trajectories first. Which brings it back to a data problem.

Agent memory is largely treated today as a problem of accumulation. This paper reframes it as a problem of what to keep and what to discard, and hands the adjudication to a separate model. That memory without a name tag cannot be erased was the subject of an earlier report, and the lineage of agents that teach themselves starts with the 2023 work this paper also cites. The problem that is new sits between them. Judging accumulated memory now needs criteria.

Building those criteria splits three ways. One is diagnosing the state of the experience store, measuring the distribution of duplication, conflict and actual usage. Two is designing the eviction and consolidation policy and verifying that the policy behaves as intended. Three is deciding by what standard successful trajectories are selected for training. The third is the problem this paper surfaced as the number 87, and all three are work already being done on training corpora.

None of this means the paper's work and data quality work are the same job. The objects differ and the time scales differ. What is clear is that the same question is being asked of a different object. What do you keep and what do you throw away, and where does the basis for that judgment come from. This paper's answer was cost.

Academic

• 1.Ning, X., Fu, D., Wei, T., et al. (2026). EvoHarness-RL: Learning Self-Evolving Runtime Harness for Long-Horizon LLM Agents. arXiv:2608.05446v1. 2026-08-05. UIUC and Meta AI, 16 authors. (Primary source for this piece: Tables 1, 2 and 3 and all figures in Appendices A through D)
• 2.Chu et al. (2025). SFT Memorizes, RL Generalizes: A Comparative Study of Foundation Model Post-training. arXiv:2501.17161. 2025-01-28. (The prior work that named out-of-distribution degradation under supervised fine-tuning and generalization under RL. The companion claim, that SFT stabilizes output format so RL can deliver, is in the same abstract)
• 3.Palmeira Ferraz, T., Deffayet, R., Nikoulina, V., Déjean, H., & Clinchant, S. (2026). Retrieval-Augmented LLM Agents: Learning to Learn from Experience. arXiv:2603.18272. 2026-03-18. (Table 1 reports a 94.1% LoRA baseline and an 89.6% rule-based expert on the official ALFWorld unseen split. The caption notes it is a cross-paper comparison to be read qualitatively, and the backbone is Qwen2.5-7B)
• 4.(2026). The Interplay of Harness Design and Post-Training in LLM Agents. arXiv:2606.25447. 2026-06-24. (Extends ALFWorld to treat the harness as a design variable and evaluates under environment shift)
• 5.(2026). HarnessBridge. arXiv:2606.12882. 2026-06-11. (Starts from the observation that existing harnesses are largely handcrafted and learns a bidirectional projection between observations and actions)
• 6.Shridhar, M., et al. (2021). ALFWorld: Aligning Text and Embodied Environments for Interactive Learning. arXiv:2010.03768. ICLR 2021. (3,553 training instances, 140 seen-split tasks, 134 unseen-split tasks, six task types)
• 7.(2023). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629. (The baseline configuration in this paper)
• 8.(2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366. (A comparison method in Table 1)
• 9.(2024). DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models. arXiv:2402.03300. (Source of the GRPO algorithm used here)

Industry primary sources

• 10.Young, J. (2025). Effective harnesses for long-running agents. Anthropic Engineering Blog. 2025-11-26. (The only industry document EvoHarness-RL cites. Source for the initializer agent, progress file, feature JSON and one-feature-at-a-time structure)
• 11.Rajasekaran, P. (2026). Harness design for long-running application development. Anthropic Engineering. 2026-03-24. (The statement that every component in a harness encodes an assumption about what the model cannot do on its own, and that those assumptions go stale as models improve)
• 12.Anthropic (2026). Scaling Managed Agents: Decoupling the brain from the hands. Anthropic Engineering. 2026-04-08. (Their own case in which context resets added for Sonnet 4.5 became dead weight on Opus 4.5)
• 13.Anthropic (2026). Claude Opus 4.5. (List price of $5 per million input tokens and $25 per million output tokens)
• 14.OpenRouter and Artificial Analysis (2026). Qwen3-8B hosting prices by provider. Accessed 2026-08. ($0.04 to $0.455 per million tokens)

Press coverage

• 15.Park, C. (2026). Meta reaches Claude Opus 4.5-level performance with an 8B model: the EvoHarness-RL paper. AI Times (Korean). 2026-08-29. (The Korean coverage this piece started from. The paper was released 2026-08-05, which differs from the coverage date)

Earlier Pebblous reports

• 16.Pebblous (2026). Memory Without a Name Tag Can't Be Erased. 2026-07-29.
• 17.Pebblous (2026). Five Ways to Make a Chatbot Remember the Conversation. 2026-07-16.
• 18.Pebblous (2026). It's the Weak Harness, Not the Weak Model, That Kills Your Agent. 2026-07-01.
• 19.Pebblous (2026). When Skill Documents Began to Learn. 2026-05-27. (Microsoft SkillOpt, arXiv:2605.23904, a different paper from the SkillOS cited in this paper's table)
• 20.Pebblous (2026). When Skills Begin to Remember. 2026-05-27.
• 21.Pebblous (2026). Voyager: The Origin of Self-Learning AI. 2026-05-24.
• 22.Pebblous. PebbloPedia: Harness. (Concept primer)