Code Is the Body: Agent-Owned Software Bodies for Recursive Evolution and Descent

(2) Independent Researcher); Roy Zhao (1); University of Washington; Zhenyu Zhao (2) ((1) Paul G. Allen School of Computer Science & Engineering

REVIEW 2 major objections 4 minor 16 references

A persistent personal agent should be understood as an owned, versioned software body that can evolve itself and fork into independently specializing descendants, with the human custodian holding merge authority.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-03 00:39 UTC pith:BJPWF6YB

load-bearing objection A useful, honestly-scoped systems paper: the architecture is plausible and the executable artifacts back the mechanism claims, but the descent validation is self-referential and should be framed as a known gap rather than a clean demonstration. the 2 major comments →

arxiv 2607.28691 v1 pith:BJPWF6YB submitted 2026-07-30 cs.SE cs.AI

Code Is the Body: Agent-Owned Software Bodies for Recursive Evolution and Descent

Roy Zhao (1) , Zhenyu Zhao (2) ((1) Paul G. Allen School of Computer Science & Engineering , University of Washington , (2) Independent Researcher) This is my paper

classification cs.SE cs.AI

keywords agent-owned software bodypersonal agentsself-evolutionrecursive descentidentity-bearing artifacthuman governancelineageversioned body

verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper tries to establish that a persistent personal agent should have an owned, identity-bearing software body — a versioned set of code, prompts, skills, policies, tests, and evolution mechanisms — and that two operations on that same body, governed self-evolution and recursive descent, are enough to let one seed agent become the root of a family of independently specializing agents. If this is right, users would control the artifact that actually determines how their agent behaves and changes, and agents could be forked like code while keeping inherited regression tests as birth contracts. The authors demonstrate the architecture with a working prototype: a creation engine that materializes descendants, a reference agent that evolves its own body, and a four-agent, three-descent linear lineage with executable regression tests. They explicitly limit the claims to architecture and mechanism evidence, not new model capability or long-term reliability.

Core claim

The core claim is that identity and continuity for a personal agent can live in a versioned body, kept separate from private state (memories, credentials, logs) and from an external reasoner whose weights can be replaced without changing who the agent is. Descent then copies a compatible body, rewrites identity-bearing text with boundary-aware string substitution, initializes a fresh private-state boundary, runs the inherited validation suite, and only then creates a birth commit — so a descendant can in turn become a parent. The paper shows this recursively across three descents and shows governed evolution in which candidate changes are proposed from six sources, isolated in version-contro

What carries the argument

The central object is the agent-owned software body: a standalone versioned artifact carrying identity, mission, code, prompts, tools, skills, policies, tests, and the update/inheritance/learning machinery, with private instance state and model inference outside it. The mechanism that makes descent work is a creation engine that records parent-at-birth and descendant-birth commits, applies boundary-aware text rewriting to identity-bearing strings, and refuses to create the birth commit until the inherited regression suite passes. Recursive compatibility — any descendant that can itself be transformed and validated may source another descent — is what turns a single seed into a branching fami

Load-bearing premise

Descent assumes that boundary-aware string substitution plus passing inherited regression tests is enough to make a copied body a semantically correct descendant; the paper itself concedes it cannot guarantee every transformed file is semantically correct, so a silent semantic break that still passes tests would mean the 'child' is not actually the parent's offspring in behavior.

What would settle it

Choose a source body with dozens of identity-bearing strings, run the creation engine to make a descendant, and diff behavior against a hand-verified copy on tasks that exercise every such string; a single birth commit whose file parses but behaves differently — or one identity-bearing string the rewrite misses — would falsify the reproducibility claim. A second decisive check is an end-to-end post-divergence inheritance attempt, which Section 7 says has not been run.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

If the body is the unit of continuity, switching model providers does not change the agent's identity; the external reasoner is peripheral.
A user could move an agent between environments by carrying the body plus private state, and the agent's behavior is inspectable as code rather than hidden in platform configuration.
Descent lets users specialize agents without synchronizing: each descendant inherits a frozen baseline and regression contracts, then diverges with its own mission, history, and private state.
Because every accepted change goes through isolated validation and human-controlled merge, agents can co-develop their own body while the human remains the final authority.
After divergence, a descendant can selectively adapt chosen parent or peer changes through its own tests and review, rather than continuously mirroring a shared base.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

The paper does not test sibling branches or population-scale selection; a natural next step is to grow a branching family from one seed and measure whether specialization improves outcomes per branch, not just whether births pass tests.
Section 7 concedes that the identity rewrite is not guaranteed to preserve semantics; one testable extension is to measure how often boundary-aware string substitution changes behavior relative to a hand-verified parse, across many source bodies.
If bodies become the portable unit, the economics of personal agents could shift from model subscription to ownership of forkable agent code, with model calls as replaceable peripherals — a consequence the paper gestures at but does not claim.
The human merge decision is effectively a selection operator; recording proposal, diff, validation, and promotion (as the prototype does) creates an auditable selection history, making the lineage a candidate substrate for artificial selection even though no selection experiment is performed here.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Desk Editor's Note

A useful, honestly-scoped systems paper: the architecture is plausible and the executable artifacts back the mechanism claims, but the descent validation is self-referential and should be framed as a known gap rather than a clean demonstration.

read the letter

The thing you should know up front: this paper is a legitimate architecture proposal with real executable evidence, not a hype piece. The core idea—that a persistent agent should have an owned, identity-bearing, versioned software body under human custody, and that evolution and descent operate on that same body—is clearly stated and cleanly separated from private state and the model. The implementation is open source, the commands are reproducible, and the reported numbers (29/29 Genesis, 753/753 Enoch, cross-artifact descent) back the mechanism claims. Give credit where due: this is a concrete step beyond MOSS or Autogenesis, which don't define whole-body offspring with a new identity and private-state boundary.

Now the soft spot, and it's real but not disqualifying. The stress-test note is right: descendant validation is circular. Genesis rewrites identity-bearing text in both the source and the tests, then runs the inherited suite. A consistent over- or under-rewrite of a package path or identity symbol can produce a green suite even when the descendant's behavior is semantically wrong in ways the suite doesn't probe. The paper acknowledges this in Section 7, saying the string substitution 'cannot guarantee that every transformed file is semantically correct.' But Section 5 still marks recursive descent as 'demonstrated,' which overstates what the evidence supports. This should be relabeled as 'mechanism-level validation with a known self-referential oracle,' or better, supplemented with an independent semantic check. It doesn't refute the architecture—the paper scopes claims to mechanisms—but it does mean the flagship demonstration is weaker than it looks.

Other weaknesses are minor and mostly self-acknowledged: one linear lineage from one team, no sibling branches, mostly mocked services, no long-term reliability or safety data, and procedural rather than tamper-evident governance. These are consistent with a prototype paper and don't undercut the claims as scoped.

Who is this for? People designing personal-agent frameworks or studying agent self-evolution. It gives them a concrete substrate to build on or argue against. I'd bring it to a reading group and I'd likely cite it if I worked on agent lineage or user-governed agents.

Recommendation for peer review: send it. The architecture is worth serious referee time, and the validation circularity is a fixable framing issue plus a request for an independent oracle, not a reason to desk reject.

Referee Report

2 major / 4 minor

Summary. The paper introduces OurArk, an architecture for persistent personal agents in which an agent's identity and behavior live in an inspectable, versioned 'body' repository, separate from private instance state and from an external model reasoner. The architecture defines two operations over the body: governed self-evolution (isolated candidate changes validated and merged under human control) and recursive descent (a compatible body is copied, identity-transformed, and independently versioned as a new agent). A reference implementation—the Genesis creation engine and the Enoch reference agent—is used to demonstrate a four-agent, three-descent lineage (Lucy→Adam→Seth→Enoch), with regression suites (29/29 and 753/753 passing) and a cross-artifact descent check. The paper carefully scopes all claims to architecture and mechanism-level evidence and lists limitations in Section 7.

Significance. If the architecture is taken at its claimed scope, the contribution is useful: it separates body, state, and reasoner; enables human-governed co-evolution; and provides a concrete, reproducible substrate for agent lineage and specialization. The open-source frozen snapshots and executable commands are genuine strengths, as is the explicit acknowledgment of what is not evaluated (long-term reliability, semantic safety, complete post-divergence transfer). The paper does not claim a benchmark result or a proof of optimality, so the absence of formal guarantees is not by itself a flaw. The main risk is that the 'demonstrated' status of recursive descent overstates the inferential power of the self-referential test suite.

major comments (2)

[§5 (evidence table, 'Recursive descent' row) and §3.3] The validation that gates a Genesis birth is the inherited test suite, which is copied into the descendant and rewritten by the same identity transform. Passing tests therefore establish self-consistency of the text rewriting, not that the transformed descendant is semantically correct. The paper already concedes this in §7: boundary-aware string substitutions 'cannot guarantee that every transformed file is semantically correct.' Because the abstract and conclusion use 'demonstrate' for recursive descent, this is a load-bearing precision issue. Please either (a) add one externally observable check on a fresh descendant (e.g., run a simple task whose output is verified independently), or (b) re-label the table and conclusion as 'mechanism demonstrated, semantic correctness not established.'
[§5 and §7 (lineage reproducibility)] The claimed four-agent, three-descent lineage is not fully reproducible from public artifacts: Lucy, Adam, and Seth are private, and §7 states the historical lineage predates the current provenance format. The public cross-artifact check in §5 creates only one fresh descendant from Enoch v0.3.1. Since recursive descent is a central contribution, please state explicitly which of the two descents are exercised by the public test suite, or provide a public two-step descent transcript generated from the frozen snapshots.

minor comments (4)

[§2] The tuple notation A = (B, S, R) and the custodian H are introduced but not used consistently in later sections. Either use the notation throughout or simplify the presentation.
[§3.3] The phrase 'boundary-aware string substitutions' is not formally specified. A short example or precise rule for what boundaries are recognized would improve reproducibility and make the limitation in §7 more concrete.
[§5] The table marks post-divergence transfer as 'partial,' but the accompanying text does not make explicit what a successful full evaluation would require. One sentence defining the missing end-to-end adaptation would help readers calibrate the claim.
[§8] Some related-work entries are arXiv preprints or software-release references rather than peer-reviewed publications. This is acceptable for a system paper, but a brief note distinguishing evaluated systems from position/vision papers would improve the comparison.

Circularity Check

0 steps flagged

No significant circularity: the paper's claims are architectural and validated by executable regression tests, with the self-referential test-transform issue explicitly disclosed as a limitation rather than a derivation.

full rationale

The paper does not derive numerical predictions from fitted parameters, nor does it invoke a load-bearing self-citation or an imported uniqueness theorem. Its central claim is that the OurArk architecture, with Genesis and the Enoch reference agent, can recursively create descendants and govern self-evolution. The evidence is a frozen prototype and its own executable regression suite: Genesis v0.1.1 passes 29/29 tests, Enoch v0.3.1 passes 753/753, and a cross-artifact gate creates a descendant and runs inherited validation. This is engineering validation, not a derivation that reduces to its inputs. The closest point to a circular validation is that the inherited suite is rewritten by the same identity transform it is used to check; Section 7 admits: 'Genesis rewrites identity-bearing text using boundary-aware string substitutions rather than language-specific parsers. Its manifest checks and inherited tests reject invalid body declarations and detected regressions, but cannot guarantee that every transformed file is semantically correct.' That is an honest limitation on the strength of the word 'demonstrated,' but it is not a circular step: the suite contains independently authored behavioral assertions, and passing it after a nontrivial identity rewrite is a meaningful consistency check. The paper itself scopes the evidence in Section 7: 'Our claims are therefore limited to architecture, implemented mechanisms, and regression evidence.' No load-bearing self-citations were found; the references are external prior art, and the recursive-compatibility criterion is explicitly defined in the paper rather than imported from the authors' prior work. Therefore no significant circularity is present.

Axiom & Free-Parameter Ledger

0 free parameters · 3 axioms · 0 invented entities

The central claim rests on design assumptions rather than empirical or mathematical axioms. The main load-bearing assumptions are that a versioned repository can serve as the durable carrier of agent identity (A1), that inherited regression tests are sufficient validation for a descendant (A2), and that boundary-aware string substitutions produce semantically correct identity rewrites (A3). The paper itself flags A3 as a limitation.

axioms (3)

domain assumption A versioned repository can serve as the durable carrier of agent identity and behavior across restarts and descent.
Introduced in Section 3.1; requires that all behavior-defining artifacts live in the body.
domain assumption Passing inherited regression tests is sufficient validation for a new descendant.
Section 3.3 makes birth commits conditional on inherited suite passing; assumes tests capture relevant behavior contracts.
ad hoc to paper Boundary-aware string substitution can transform identity-bearing text without language-specific parsing and still yield a correct descendant.
Section 7 admits this is not guaranteed; it is a prototype design choice.

pith-pipeline@v1.3.0-alltime-deepseek · 236 in / 7247 out tokens · 177073 ms · 2026-08-03T00:39:49.769625+00:00 · methodology

0 comments

read the original abstract

Personalized AI agents are often configurable without giving users control over the artifacts that determine their future behavior. We present OurArk, an architecture for persistent personal agents centered on an agent-owned software body: an identity-bearing, inspectable, and versioned artifact under human custody. The body contains behavior-defining code, prompts, tools, skills, policies, tests, and evolution mechanisms. Memories and credentials remain private instance state, while model inference is treated as a replaceable external service. OurArk defines governed self-evolution and recursive descent over the same body. Self-evolution produces isolated candidate changes that are validated, reviewed, and merged under human control, enabling human-agent co-development of the agent's software body. Descent creates an independently versioned descendant with a distinct identity, mission, history, and fresh private-state boundary; compatible descendants can themselves source further descent. After divergence, direct-parent changes and peer skills can be inspected for selective local adaptation. We implement the architecture in the open-source Genesis creation engine and Enoch reference agent. A four-agent, three-descent linear lineage and executable regression tests demonstrate recursive creation, inherited validation contracts, isolated body changes, human-controlled review, and failed-update recovery. OurArk provides a concrete substrate for personal agents that people can possess, govern, specialize, and evolve over time.

Figures

Figures reproduced from arXiv: 2607.28691 by (2) Independent Researcher), Roy Zhao (1), University of Washington, Zhenyu Zhao (2) ((1) Paul G. Allen School of Computer Science & Engineering.

**Figure 1.** Figure 1: Body, state, reasoner, and custodian boundaries. The versioned body carries identity and evolvable behavior across restarts and descent. Private state belongs to one instance, the reasoner can be replaced without redefining lineage, and the human custodian retains administrative and promotion authority. Descent copies the body, initializes a new private-state boundary, and does not inherit model weights. 3… view at source ↗

**Figure 2.** Figure 2: Recursive descent. Solid lineage edges show the implemented linear prototype. The dashed lineage edge from Adam shows a branch permitted by the architecture but not evaluated. Genesis materializes each birth from a selected compatible body and is not the runtime owner of descendants. 3.1 The repository as body An agent body is represented by a standalone, versioned repository containing: • a machine-readab… view at source ↗

**Figure 3.** Figure 3: Single-lane co-evolution flow. Six sources expose candidate pressures, the human and agent jointly shape a candidate body change, validation checks it, and the human controls promotion. A failed or rejected candidate leaves the authoritative body unchanged. agent’s body and can initiate the change workflow directly. Feedback and experience are derived from prior conversation turns and work-event histories … view at source ↗

discussion (0)

Reference graph

Works this paper leans on

16 extracted references · 1 canonical work pages

[1]

O’Brien, Carrie Jun Cai, Meredith Ringel Morris, Percy Liang, and Michael S

Joon Sung Park, Joseph C. O’Brien, Carrie Jun Cai, Meredith Ringel Morris, Percy Liang, and Michael S. Bernstein. Generative agents: Interactive simulacra of human behavior. InProceedings of the 36th Annual ACM Symposium on User Interface Software and Technology, UIST ’23, pages 1–22, New York, NY, USA, 2023. Association for Computing Machinery. Article 2...

arXiv 2023
[2]

Voyager: An open-ended embodied agent with large language models, 2023

Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models, 2023. arXiv:2305.16291

Pith/arXiv arXiv 2023
[3]

SkillFlow: Efficient skill and code transfer through com- munication in adapting AI agents, 2025

Pagkratios Tagkopoulos, Fangzhou Li, and Ilias Tagkopoulos. SkillFlow: Efficient skill and code transfer through com- munication in adapting AI agents, 2025. arXiv:2504.06188v1

arXiv 2025
[4]

OpenClaw: Personal AI assistant

OpenClaw Foundation. OpenClaw: Personal AI assistant. Software release, July 2026. Version v2026.7.1, released July 13, 2026;https://github.com/openclaw/openclaw/releases/tag/v2026.7.1

2026
[5]

Hermes agent

Nous Research. Hermes agent. Software release, July 2026. Version v0.19.0, tag v2026.7.20, released July 20, 2026; https://github.com/NousResearch/hermes-agent/releases/tag/v2026.7.20

2026
[6]

Gödel Machines: Self-referential universal problem solvers making provably optimal self- improvements, 2003

Jürgen Schmidhuber. Gödel Machines: Self-referential universal problem solvers making provably optimal self- improvements, 2003. arXiv:cs/0309048; revised 2006

Pith/arXiv arXiv 2003
[7]

Darwin Gödel machine: Open-ended evolution of self-improving agents, 2025

Jenny Zhang, Shengran Hu, Cong Lu, Robert Lange, and Jeff Clune. Darwin Gödel machine: Open-ended evolution of self-improving agents, 2025. arXiv:2505.22954

Pith/arXiv arXiv 2025
[8]

Live-SWE-agent: Can software engi- neering agents self-evolve on the fly?, 2025

Chunqiu Steven Xia, Zhe Wang, Yan Yang, Yuxiang Wei, and Lingming Zhang. Live-SWE-agent: Can software engi- neering agents self-evolve on the fly?, 2025. arXiv:2511.13646

arXiv 2025
[9]

A self-improving coding agent, 2025

Maxime Robeyns, Martin Szummer, and Laurence Aitchison. A self-improving coding agent, 2025. arXiv:2504.15228

Pith/arXiv arXiv 2025
[10]

MOSS: Self-evolution through source-level rewriting in autonomous agent systems, 2026

QianshuCai, YonggangZhang, XianzhangJia, HuajiangZheng, WeiXue, JunSong, XinmeiTian, andYikeGuo. MOSS: Self-evolution through source-level rewriting in autonomous agent systems, 2026. arXiv:2605.22794. 8

Pith/arXiv arXiv 2026
[11]

Autogenesis: Aself-evolving agent protocol, 2026

WentaoZhang,ZheZhao,HaibinWen,YingchengWu,CankunGuo,MingYin,andBoAn. Autogenesis: Aself-evolving agent protocol, 2026. arXiv:2604.15034

Pith/arXiv arXiv 2026
[12]

Self-harness: Harnesses that improve themselves, 2026

HangfanZhang,ShaoZhang,KangcongLi,ChenZhang,YangChen,YiqunZhang,LeiBai,andShuyueHu. Self-harness: Harnesses that improve themselves, 2026. arXiv:2606.09498

Pith/arXiv arXiv 2026
[13]

SemaClaw: A step towards general-purpose personal AI agents through harness engineering, 2026

NingyanZhu,HuacanWang,JieZhou,FeiyuChen,ShuoZhang,GeChen,ChenLiu,JiarouWu,WangyiChen,Xiaofeng Mou, and Yi Xu. SemaClaw: A step towards general-purpose personal AI agents through harness engineering, 2026. arXiv:2604.11548

Pith/arXiv arXiv 2026
[14]

EvoGit: Decentralized code evolution via Git-based multi-agent collab- oration, 2025

Beichen Huang, Ran Cheng, and Kay Chen Tan. EvoGit: Decentralized code evolution via Git-based multi-agent collab- oration, 2025. arXiv:2506.02049

Pith/arXiv arXiv 2025
[15]

Agent libOS: A runtime substrate for capability-controlled self-evolving LLM agents, 2026

Yingqi Zhang. Agent libOS: A runtime substrate for capability-controlled self-evolving LLM agents, 2026. arXiv:2606.03895

Pith/arXiv arXiv 2026
[16]

Reuse and maintenance practices among divergent forks in three software ecosystems.Empirical Software Engineering, 27:54, 2022

John Businge, Moses Openja, Sarah Nadi, and Thorsten Berger. Reuse and maintenance practices among divergent forks in three software ecosystems.Empirical Software Engineering, 27:54, 2022. Article 54; doi:10.1007/s10664-021-10078- 2. 9

work page doi:10.1007/s10664-021-10078- 2022

[1] [1]

O’Brien, Carrie Jun Cai, Meredith Ringel Morris, Percy Liang, and Michael S

Joon Sung Park, Joseph C. O’Brien, Carrie Jun Cai, Meredith Ringel Morris, Percy Liang, and Michael S. Bernstein. Generative agents: Interactive simulacra of human behavior. InProceedings of the 36th Annual ACM Symposium on User Interface Software and Technology, UIST ’23, pages 1–22, New York, NY, USA, 2023. Association for Computing Machinery. Article 2...

arXiv 2023

[2] [2]

Voyager: An open-ended embodied agent with large language models, 2023

Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models, 2023. arXiv:2305.16291

Pith/arXiv arXiv 2023

[3] [3]

SkillFlow: Efficient skill and code transfer through com- munication in adapting AI agents, 2025

Pagkratios Tagkopoulos, Fangzhou Li, and Ilias Tagkopoulos. SkillFlow: Efficient skill and code transfer through com- munication in adapting AI agents, 2025. arXiv:2504.06188v1

arXiv 2025

[4] [4]

OpenClaw: Personal AI assistant

OpenClaw Foundation. OpenClaw: Personal AI assistant. Software release, July 2026. Version v2026.7.1, released July 13, 2026;https://github.com/openclaw/openclaw/releases/tag/v2026.7.1

2026

[5] [5]

Hermes agent

Nous Research. Hermes agent. Software release, July 2026. Version v0.19.0, tag v2026.7.20, released July 20, 2026; https://github.com/NousResearch/hermes-agent/releases/tag/v2026.7.20

2026

[6] [6]

Gödel Machines: Self-referential universal problem solvers making provably optimal self- improvements, 2003

Jürgen Schmidhuber. Gödel Machines: Self-referential universal problem solvers making provably optimal self- improvements, 2003. arXiv:cs/0309048; revised 2006

Pith/arXiv arXiv 2003

[7] [7]

Darwin Gödel machine: Open-ended evolution of self-improving agents, 2025

Jenny Zhang, Shengran Hu, Cong Lu, Robert Lange, and Jeff Clune. Darwin Gödel machine: Open-ended evolution of self-improving agents, 2025. arXiv:2505.22954

Pith/arXiv arXiv 2025

[8] [8]

Live-SWE-agent: Can software engi- neering agents self-evolve on the fly?, 2025

Chunqiu Steven Xia, Zhe Wang, Yan Yang, Yuxiang Wei, and Lingming Zhang. Live-SWE-agent: Can software engi- neering agents self-evolve on the fly?, 2025. arXiv:2511.13646

arXiv 2025

[9] [9]

A self-improving coding agent, 2025

Maxime Robeyns, Martin Szummer, and Laurence Aitchison. A self-improving coding agent, 2025. arXiv:2504.15228

Pith/arXiv arXiv 2025

[10] [10]

MOSS: Self-evolution through source-level rewriting in autonomous agent systems, 2026

QianshuCai, YonggangZhang, XianzhangJia, HuajiangZheng, WeiXue, JunSong, XinmeiTian, andYikeGuo. MOSS: Self-evolution through source-level rewriting in autonomous agent systems, 2026. arXiv:2605.22794. 8

Pith/arXiv arXiv 2026

[11] [11]

Autogenesis: Aself-evolving agent protocol, 2026

WentaoZhang,ZheZhao,HaibinWen,YingchengWu,CankunGuo,MingYin,andBoAn. Autogenesis: Aself-evolving agent protocol, 2026. arXiv:2604.15034

Pith/arXiv arXiv 2026

[12] [12]

Self-harness: Harnesses that improve themselves, 2026

HangfanZhang,ShaoZhang,KangcongLi,ChenZhang,YangChen,YiqunZhang,LeiBai,andShuyueHu. Self-harness: Harnesses that improve themselves, 2026. arXiv:2606.09498

Pith/arXiv arXiv 2026

[13] [13]

SemaClaw: A step towards general-purpose personal AI agents through harness engineering, 2026

NingyanZhu,HuacanWang,JieZhou,FeiyuChen,ShuoZhang,GeChen,ChenLiu,JiarouWu,WangyiChen,Xiaofeng Mou, and Yi Xu. SemaClaw: A step towards general-purpose personal AI agents through harness engineering, 2026. arXiv:2604.11548

Pith/arXiv arXiv 2026

[14] [14]

EvoGit: Decentralized code evolution via Git-based multi-agent collab- oration, 2025

Beichen Huang, Ran Cheng, and Kay Chen Tan. EvoGit: Decentralized code evolution via Git-based multi-agent collab- oration, 2025. arXiv:2506.02049

Pith/arXiv arXiv 2025

[15] [15]

Agent libOS: A runtime substrate for capability-controlled self-evolving LLM agents, 2026

Yingqi Zhang. Agent libOS: A runtime substrate for capability-controlled self-evolving LLM agents, 2026. arXiv:2606.03895

Pith/arXiv arXiv 2026

[16] [16]

Reuse and maintenance practices among divergent forks in three software ecosystems.Empirical Software Engineering, 27:54, 2022

John Businge, Moses Openja, Sarah Nadi, and Thorsten Berger. Reuse and maintenance practices among divergent forks in three software ecosystems.Empirical Software Engineering, 27:54, 2022. Article 54; doi:10.1007/s10664-021-10078- 2. 9

work page doi:10.1007/s10664-021-10078- 2022