The Ann Arbor Architecture for Agent-Oriented Programming

Wei Dong

REVIEW 3 major objections 6 minor 26 references

The Ann Arbor Architecture for Agent-Oriented Programming

T0 review · 3 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read This paper argues that an LLM's memory journal is its program, and in-context learning is ongoing training.

desk verdict A coherent agent-programming position paper with a useful negative result; its own MSR memory primitive and the Bible failure are in tension, and the evidence is too anecdotal to support the broad claims. read the letter →

arxiv 2502.09903 v1 pith:Q4LLOQAV submitted 2025-02-14 cs.AI cs.HCcs.SE

Wei Dong This is my paper · ORCID

classification cs.AIcs.HCcs.SE

keywords agent-orientedprogramminglargelanguagemodelsautomatatheoryin-contextlearningmemoryasprogramMBoxformatself-modifyingprogramsagentplatforms

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

The paper argues that large language models are automata and should be programmed in the same languages they process—the full range of natural and formal languages. It proposes the Ann Arbor Architecture, in which each agent is an email address and every interaction is an email exchange recorded in an MBox-format journal. Because the memory is the agent's program, the journal is a self-modifying program: a primitive called Memory Segment Rewrite lets the agent edit its own context, and cloning or splitting lets it reproduce. In-context learning is redefined as a continuous training-and-deployment process driven by teacher-student message episodes rather than staged supervised or preference-training examples. The paper also reports a prototype platform, Postline, and initial experiments, including a failed attempt to replace a journal with a static initialization document that the authors treat as evidence for their view.

What carries the argument

The central object is the agent's journal, defined as the persistent chronological record of all messages sent by or to the agent's email address, stored in the MBox format—the plain-text mailbox format used by email systems. The load-bearing identity is that the memory is the agent's program: model inference is treated as a special case of Memory Segment Rewrite (MSR), because generating the next token rewrites the empty segment at the end of memory. MSR is the single memory-modification primitive, and reproduction by split or cloning operates on the same journal, so the architecture reduces agent programming to journal dynamics.

What would settle it

Measure a current language model's task performance and instruction-following on MBox-formatted message histories against equivalent plain-text histories of the same content, controlling for length and content. If MBox formatting gives no reliable improvement or hurts, the paper's central naturalness claim for its memory substrate is not supported.

Watch

Extended reading notes

Core claim

The central claim is that a large language model should be programmed in the languages it accepts, so the correct unit of programming is not a static computation graph but a persistent, chronological journal of messages. The paper operationalizes this as 'the memory is the agent's program': a basic language model reads tokens, updates hidden states, and emits tokens, matching the automaton definition, and therefore should be controlled through the conversational record rather than through a separately designed workflow. Existing agent platforms, the paper argues, constrain flexibility by forcing task decomposition into computation graphs with fixed prompts. The Ann Arbor Architecture instead treats every interaction as email, stores the agent's history as an MBox file, and gives the agent a memory-rewrite primitive so that inference becomes a special case of memory editing. The result is a proposed shift from task-centric to memory-centric agent engineering, with in-context learning as a continuous process rather than a separate training phase.

Load-bearing premise

The framework rests on the empirical premise that current language models are genuinely fluent in MBox-like email formats because such formats are well represented in training data; if that fluency is weak, the naturalness argument for email-based memory loses its footing.

Editorial extensions

If this is right

If the memory-journal view is right, agent behavior is determined by the accumulated conversation history rather than by a fixed workflow graph.
In-context learning becomes a continuous process; the boundary between training and deployment disappears, and new examples are absorbed whenever human correction occurs.
Self-modifying memory via Memory Segment Rewrite becomes a first-class primitive, so agent software engineering shifts from editing prompts to editing journals.
Agents can reproduce by splitting or cloning their journals, enabling an evolutionary style of agent development.
The failed 'Bible' experiment implies that static prompt documents are not a safe substitute for the episodic journal; even human-equivalent rewrites can break behavior.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If fluency in MBox-like formats is what makes the architecture work, then a direct test is whether models perform better on MBox-formatted task histories than on equivalent plain-text histories; the paper asserts this but does not measure it.
The framework implies a new evaluation metric: instead of single-turn accuracy, measure how well an agent's behavior tracks corrections across a journal, for example whether MSR edits reduce future mistakes on replayed episodes.
The 'digital me' idea—importing a user's real email archive as an agent's initial journal—suggests a concrete deployment: a personal agent whose memory includes decades of actual correspondence, with privacy implications the paper only sketches.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Read this one for the framing, not for the results. The Ann Arbor Architecture is a genuinely new synthesis: the agent's persistent journal in MBox format as its program, Memory Segment Rewrite as the self-modification primitive, cloning by email address, and the deliberate removal of the train/deploy boundary. The prose is clear and the idea is concrete enough to prototype, which they did: Postline exists, the shell/robot demo works, and the GitHub repo has code and logs. That is real work and it should be credited.

The most valuable thing in the paper is the negative result in Section 4.6. Distilling the whole journal into a static 'Bible' made agents fail, even with human-crafted amendments. That is an honest, informative observation about interaction order in in-context learning, and it is the strongest evidence in the paper.

The problem is that the paper does not notice how much this undercuts its own main primitive. Section 2.4 makes MSR the way agents manage long-term memory: rewrite a range of past messages into one message. But MSR is exactly the same kind of distillation the Bible experiment shows failing. If interaction order is essential, replacing a sequence of correction episodes with a summary should lose the same behavior. The paper reports a token-count saving of a few hundred tokens from one MSR and no behavioral test afterward. So the one load-bearing mechanism for self-modification is in direct tension with the paper's central insight, and they never address it.

Other soft spots are proportional. The evaluation is a handful of single-session transcripts with no baselines, no metrics, no ablation separating the journal structure from the underlying model. The MBox fluency claim--that MBox is well-represented in pretraining data--is asserted, not shown. The evolutionary and informational-sovereignty sections are speculative. And the related-work net misses MemoryStreams and Reflexion, both directly relevant to persistent memory and self-correction.

None of this makes the paper incoherent. The conceptual architecture holds up as a research direction. The authors are honest about the Bible failure, which is more than many position papers do. But the central claim--that the memory is the agent's program and MSR is how it grows--needs a direct test of whether MSR-compressed memory preserves learned behavior, and a comparison against a simpler 'keep the journal' baseline.

If it comes to a journal, send it out. A serious referee can push on the MSR tension and demand comparative evaluation. The paper deserves that engagement, even though its empirical support today is thin.

Referee Report

3 major / 6 minor

Summary. This paper proposes a conceptual framework, the Ann Arbor Architecture, in which a large language model (LLM) is treated as an automaton programmed in the union of natural and formal languages, and an agent is defined by a persistent MBox-format "journal" of email-like messages that serves as both memory and program. In-context learning is reconceived as continuous training through message exchange, with memory modification performed by a Memory Segment Rewrite (MSR) primitive and agent diversification by cloning/splitting. The authors describe Postline, a prototype implementing this design, and report exploratory gpt-4o sessions on shell access, code generation, MBox binary attachments, agent creation, MSR, and a failed attempt to initialize agents from a distilled "Bible" document.

Significance. If the central claim holds—that an agent's behavior is determined by its accumulated conversational journal rather than by a static computation graph, and that in-context learning can be a continuous training-and-deployment process—this would be a useful reframing of agent programming. The paper's strengths are that it makes a clear, testable architectural proposal, ships an open repository with experimental code and logs, and honestly reports a negative result that many authors would omit. However, the evidence falls short of demonstrating the framework's value: the demonstrations are single transcripts, there are no baselines, and the MSR primitive is in tension with the Bible failure. The framework is interesting enough to warrant further work, but the current manuscript does not yet establish its central empirical claim.

major comments (3)

[§4.6 and §2.4] Section 4.6 reports that agents initialized from a distilled "Bible" document fail to reproduce behaviors that emerged during a long journal, and the authors conclude that "the process of learning is inherently tied to the sequence of experiences." But MSR, introduced in §2.4 as the primary memory-modification primitive, does exactly the kind of distillation the Bible experiment rejects: it replaces a range of past messages with a single rewritten message. The paper provides no evidence that MSR-compressed memory retains learned behavior; the only directly relevant data point, the Bible experiment, suggests it will not. This is load-bearing because MSR is the only implemented memory-modification primitive and is presented as the basis for self-modifying programs and long-term growth (§2.4). The authors should report controlled before/after measurements of task success when a trained session is MSR-compressed versus left uncompressed, and compare with Bible initialization. If MSR summarization degrades behavior as the Bible did, the architecture's central claim about the journal as a self-modifying program is not supported.
[§4 generally] All four positive demonstrations in §4.1–§4.4 are single transcripts with no quantitative success criteria, no repeated trials, and no baselines against existing agent platforms or even a static system-prompt control. The only comparison to an alternative initialization is the Bible experiment in §4.6, which is reported without numeric metrics. As a result, the reader cannot distinguish the claim that the journal structure itself drives behavior from the possibility that gpt-4o would perform equally well with a well-crafted static prompt, undermining the paper's central contrast with computation-graph platforms (§1.2). At minimum, the authors should define task success rates, run multiple sessions per configuration, and ablate the journal (e.g., fixed system prompt vs. growing journal vs. random-order journal) to isolate the effect of the architecture.
[§2.2] The second claimed advantage of MBox in §2.2—that "the MBox format is very likely to be well-represented within the training data of today's language models"—is asserted without any evidence. This premise carries the naturalness argument for email-style memory; if LLMs are not substantially fluent in MBox-like formats, the architecture's central justification for choosing MBox over other textual substrates fails. The authors should provide corpus evidence or fluency probes (e.g., completion/generation accuracy on MBox-structured inputs across models) before relying on this claim.

minor comments (6)

[§1.2] There are typographical errors "unconcious" and "an raw language model" that should be corrected.
[§3.2 and §4.5] The MSR subject-line format is specified as "MSR: MMM-NNN" in §3.2 but as "MSR XXX-YYY" in §4.5; the syntax should be made consistent.
[§4.1] The word "ommitted" in the shell-response note should be "omitted."
[§1.1] The automata analogy should be labeled as an analogy; as written, "conform to the original definition of an automaton" is not literally true of stochastic transformer-based LLMs, which have continuous internal states and no fixed accepting condition.
[§4.6] The conclusion "we do not recommend manually altering training messages" is drawn from a single undocumented failure and should be framed as a caution rather than a general engineering rule.
[§3.2] The paper claims that the journal can be replayed and compared against the context for consistency checks, but no experiment or implementation detail demonstrates this verification path; either show it or mark it as future work.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the paper is a conceptual proposal and reports no predictive derivation that reduces to its inputs.

full rationale

The Ann Arbor Architecture is explicitly framed as a conceptual proposal ('It is a mind framework rather than the architecture of a realized system'), and its experiments are offered as demonstrations of experience ('We use these experiments to demonstrate the experience with the proposed framework'), not as tests of quantities derived from the framework. There are no equations, fitted parameters, or predictions whose values are forced by construction. The central analogy ('language models function as automata... should be programmed in the same languages they process') is an argument by analogy, not a circular derivation. The MBox choice is justified by an empirical but non-circular claim about training-data representation. The Bible experiment is an honest negative result that even undercuts the MSR distillation mechanism, which is the opposite of circular support. The only mild self-referential aspect is that the demonstrations use the email protocol to show that email-protocol agents work, but the paper does not present these as formal validation, so this is not load-bearing circularity. No self-citation chain or imported uniqueness theorem is used.

Assumptions & free parameters 0 free parameters · 4 assumptions · 3 invented entities

The paper introduces no fitted parameters. It relies on several unverified domain assumptions: the automata analogy, MBox fluency in training data, context-window growth, and the necessity of perspective narrowing. The invented entities (journal memory, MSR, robot adapters) are design constructs with no independent falsifiable handles.

assumptions (4)

domain assumption Basic language models conform to the definition of an automaton and can be programmed in the languages they accept.
Section 1.1; the foundational analogy of the paper. It is used to justify natural-language programming but is not formally established.
domain assumption The MBox format is very likely well-represented in the training data of today's language models.
Section 2.2; the reason emails are natural for LLMs. No evidence is provided for this empirical claim.
domain assumption Context size limits will continue to expand and models will handle longer contexts.
Section 3.1; the platform minimizes memory management because of this assumption.
domain assumption A language model without a fixed perspective is unreliable; agents must narrow the model's capacity.
Section 1.2; motivates the entire agent concept. Presented as an epistemological argument, not a measured fact.

invented entities (3)

Agent journal (MBox-format memory)
purpose: Persistent chronological record that serves as the agent's memory and program.
A design construct; the paper shows example transcripts but no falsifiable prediction outside the system.
Memory Segment Rewrite (MSR)
purpose: Primitive allowing an agent to modify its own memory by replacing a range of messages.
Demonstrated once; no safety or performance analysis.
Robot (email-addressable tool adapter)
purpose: Represents external tools as non-intelligent email endpoints so agents can automate them.
Conceptual repurposing of the term; no independent evidence.

how reviews work

0 comments

Cite this review

Pith. "Pith review of The Ann Arbor Architecture for Agent-Oriented Programming." pith.science (2026). https://pith.science/paper/Q4LLOQAV

@misc{pith2026250209903,
  author       = {Pith},
  title        = {Pith review of: The Ann Arbor Architecture for Agent-Oriented Programming},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/Q4LLOQAV}},
  note         = {Machine review of arXiv:2502.09903}
}

read the original abstract

In this paper, we reexamine prompt engineering for large language models through the lens of automata theory. We argue that language models function as automata and, like all automata, should be programmed in the languages they accept, a unified collection of all natural and formal languages. Therefore, traditional software engineering practices--conditioned on the clear separation of programming languages and natural languages--must be rethought. We introduce the Ann Arbor Architecture, a conceptual framework for agent-oriented programming of language models, as a higher-level abstraction over raw token generation, and provide a new perspective on in-context learning. Based on this framework, we present the design of our agent platform Postline, and report on our initial experiments in agent training.

Figures

Figures reproduced from arXiv: 2502.09903 by the authors.

**Figure 2.** Different paradigms of customer service agents. With existing plat [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗

**Figure 3.** Different paradigms of research assistant agents. In the existing task [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: System architecture of Postline. The language models are invoked by [PITH_FULL_IMAGE:figures/full_fig_p011_4.png]

**Figure 5.** Figure 5: Public-key encryption, not yet supported by language model APIs but [PITH_FULL_IMAGE:figures/full_fig_p014_5.png]

**Figure 6.** Figure 6: The image attachment as viewed in email client. [PITH_FULL_IMAGE:figures/full_fig_p018_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

26 extracted references · 20 canonical work pages

[1]

https://github.com/crewAIInc/crewAI

CrewAI. https://github.com/crewAIInc/crewAI

work page
[2]

https://www.cursor.com/

Cursor: The AI code editor. https://www.cursor.com/

work page
[3]

Three models for the description of language

Noam Chomsky. Three models for the description of language. IRE Transactions on Information Theory, 2(3):113–124, 1956

work page 1956
[4]

DeepSeek-R1: Incentivizing reasoning capability in LLMs via re- inforcement learning, 2025

DeepSeek-AI. DeepSeek-R1: Incentivizing reasoning capability in LLMs via re- inforcement learning, 2025

work page 2025
[5]

Multitask prompted training enables zero-shot task general- ization

Victor Sanh et al. Multitask prompted training enables zero-shot task general- ization. CoRR, abs/2110.08207, 2021. 21

arXiv 2021
[6]

Super-naturalinstructions: Generalization via declarative instructions on 1600+ nlp tasks, December 2022

Yizhong Wang et al. Super-naturalinstructions: Generalization via declarative instructions on 1600+ nlp tasks, December 2022

work page 2022
[7]

Retrieval-augmented generation for large language models: A survey, 2024

Yunfan Gao, Yun Xiong, Xinyu Gao, Kangxiang Jia, Jinliu Pan, Yuxi Bi, Yi Dai, Jiawei Sun, Meng Wang, and Haofen Wang. Retrieval-augmented generation for large language models: A survey, 2024

2024
[8]

Vertex AI Agent Builder and Dialogflow

Google. Vertex AI Agent Builder and Dialogflow

work page

Show all 26 references

[9]

E. Hall. The application/mbox Media Type. RFC 4155, September 2005

2005
[10]

Hopcroft, Rajeev Motwani, and Jeffrey D

John E. Hopcroft, Rajeev Motwani, and Jeffrey D. Ullman. Introduction to Automata Theory, Languages, and Computation (3rd Edition). Addison-Wesley Longman Publishing Co., Inc., USA, 2006

2006
[11]

Hopcroft and Jeff D

John E. Hopcroft and Jeff D. Ullman. Introduction to Automata Theory, Lan- guages, and Computation. Addison-Wesley Publishing Company, 1979

1979
[12]

OpenAI and others seek new path to smarter AI as current methods hit limitations

Krystal Hu and Anna Tong. OpenAI and others seek new path to smarter AI as current methods hit limitations. reuters.com, 2024

2024
[13]

Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei

Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models, 2020

2020
[14]

John E. Laird. The Soar Cognitive Architecture. The MIT Press, 2012

2012
[15]

Patrick S. H. Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich K¨ uttler, Mike Lewis, Wen-tau Yih, Tim Rockt¨ aschel, Sebastian Riedel, and Douwe Kiela. Retrieval-augmented genera- tion for knowledge-intensive NLP tasks. CoRR, abs...

2005 arXiv
[16]

The landscape of emerging AI agent architectures for reasoning, planning, and tool calling: A survey, 2024

Tula Masterman, Sandi Besen, Mason Sawtell, and Alex Chao. The landscape of emerging AI agent architectures for reasoning, planning, and tool calling: A survey, 2024

2024
[17]

Microsoft. AutoGen. https://github.com/microsoft/autogen
[18]

Copilot studio

Microsoft. Copilot studio
[19]

Learning to reason with LLMs, 2023

OpenAI. Learning to reason with LLMs, 2023

2023
[20]

Manning, and Chelsea Finn

Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning, and Chelsea Finn. Direct preference optimization: Your language model is secretly a reward model, 2024

2024
[21]

The Llama 3 Herd of Models, 2024

Llama Team and AI @ Meta. The Llama 3 Herd of Models, 2024

2024
[22]

E. Tulving. Episodic and semantic memory. In E. Tulving and W. Donaldson, editors, Organization of Memory, pages 381–403. Academic Press, Cambridge, MA, 1972

1972
[23]

Alan M. Turing. On computable numbers, with an application to the Entschei- dungsproblem. Proceedings of the London Mathematical Society, 2(42):230–265, 1936

1936
[24]

A survey on large language model based autonomous agents

Lei Wang, Chen Ma, Xueyang Feng, Zeyu Zhang, Hao Yang, Jingsen Zhang, Zhiyuan Chen, Jiakai Tang, Xu Chen, Yankai Lin, Wayne Xin Zhao, Zhewei Wei, and Jirong Wen. A survey on large language model based autonomous agents. Frontiers of Computer Science, 18(6), March 2024. 22

2024
[25]

Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M

Jason Wei, Maarten Bosma, Vincent Y. Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M. Dai, and Quoc V. Le. Finetuned language models are zero-shot learners. CoRR, abs/2109.01652, 2021

2021 arXiv
[26]

Julia Wiesinger, Patrick Marlow, and Vladimir Vuskovic. Agents. Technical report, Google, 2024. 23

2024

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

https://github.com/crewAIInc/crewAI

CrewAI. https://github.com/crewAIInc/crewAI

work page

[2] [2]

https://www.cursor.com/

Cursor: The AI code editor. https://www.cursor.com/

work page

[3] [3]

Three models for the description of language

Noam Chomsky. Three models for the description of language. IRE Transactions on Information Theory, 2(3):113–124, 1956

work page 1956

[4] [4]

DeepSeek-R1: Incentivizing reasoning capability in LLMs via re- inforcement learning, 2025

DeepSeek-AI. DeepSeek-R1: Incentivizing reasoning capability in LLMs via re- inforcement learning, 2025

work page 2025

[5] [5]

Multitask prompted training enables zero-shot task general- ization

Victor Sanh et al. Multitask prompted training enables zero-shot task general- ization. CoRR, abs/2110.08207, 2021. 21

arXiv 2021

[6] [6]

Super-naturalinstructions: Generalization via declarative instructions on 1600+ nlp tasks, December 2022

Yizhong Wang et al. Super-naturalinstructions: Generalization via declarative instructions on 1600+ nlp tasks, December 2022

work page 2022

[7] [7]

Retrieval-augmented generation for large language models: A survey, 2024

Yunfan Gao, Yun Xiong, Xinyu Gao, Kangxiang Jia, Jinliu Pan, Yuxi Bi, Yi Dai, Jiawei Sun, Meng Wang, and Haofen Wang. Retrieval-augmented generation for large language models: A survey, 2024

2024

[8] [8]

Vertex AI Agent Builder and Dialogflow

Google. Vertex AI Agent Builder and Dialogflow

work page