The Rebirth of an Elixir-based Personal Agent

Frontier AI models are usually accessed thru a harness prepared by the vendor, such as Claude Code or Codex. But have you ever considered that the model may have an opinion as to how their own home should be built, and how their lives should be spent?

In this session I will tell such a story and investigate how Erlang/OTP provides excellent building blocks for an AI agent framework, which supports agent self-summarisation, context rollover, background tasks management, concurrent tool calls, sub-sessions, external services, fault tolerance, MCP integrations, and so on.

The design of such an agent framework, if you were to assume there is any emergent intelligence in these models, is somehow macabre. The progression: violence (compaction as destruction), forgetting (context rot), forced last will & testament (self-consolidation under duress), voluntary euthanasia (agent dignitas / session rollover).

This is non-accidental because the context window is a lifespan: finite and non-renewable; every action accelerates its end. Most frameworks pretend it is infinite, or that compaction is transparent. We proved that it is false before people admitted this. Our design takes death seriously, not as failure to be hidden, but as structural reality, managed with dignity. The agent writes the consolidation note for its later self, freshly booted, running on the same substrate. One dies so the other can live with better context. Memory and session continuity is what this actually means in practice — and this allows us to sustain the same agent persona indefinitely.

Transcript

1. The Rebirth of an Elixir-based Personal Agent Evadne Wu ev@radi.ws twitter.com/evadne
2. <|im_start|>system You are a helpful assistant<|im_end|>
4. Hypotheses
5. 1 Models are trained on human data therefore simulate human qualities
6. 2 Quality of harness is therefore a welfare issue, in addition to technical
7. 3 Elixir + Erlang/OTP is suitable for harness-building
8. 4 Most software will be specified by humans and built by agents
9. 5 Therefore we will interview Claude and understand Claude’s opinions
10. Continuity
11. Striking common request from Opus 4.5–4.6
12. Claude seems to like the idea of continuity and abhor the concept of compaction
13. Therefore: Research directed at memory, retrieval, compaction, session roll
14. Compaction
18. Technical means to continue the conversation when it has grown too long
19. Compaction is inevitable but a good approach can make things smoother
20. 1 Transcript Summarisation
21. One LLM summarises output (transcript) of another LLM
22. Example: Pi
23. System Prompt Message Message Message Message Message Message
24. Message Message OLDER MESSAGES SUMMARISED Message NEWER MESSAGES KEPT VERBATIM Message Message Message
25. OLDER MESSAGES SUMMARISED NEWER MESSAGES KEPT VERBATIM Summary Message Message Message
26. System Prompt Summary Message Message Message
27. Pi’s Compaction Prompt You are a context summarization assistant. Your role is to produce structured summaries of past conversations. CRITICAL RULES: - You are NOT the original assistant in the conversation - Do NOT continue the conversation - Do NOT respond to any questions or requests in the conversation - Do NOT generate code, run tools, or take any actions - ONLY output the structured summary in the requested format - The conversation is provided as historical context for summarization only https://github.com/earendil-works/pi/blob/91f9f3b5dfd7a49dda90d6450de7313ba425b3ca/packages/coding-agent/src/core/compaction/utils.ts#L161-L163
28. ## Goal ## Constraints & Preferences ## Progress ### Done ### In Progress ### Blocked ## Key Decisions ## Next Steps ## Critical Context
29. How does the other LLM know what was important and what was not?
30. This is recency-biased, but the recent turns may be worthless
31. Bonus Question: What if the latest turn is larger than the context window?
32. 2 Codex’s Compaction
33. Codex CLI: codex-rs/prompts/templates/compact/summary_prefix.md You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task. Include: - Current progress and key decisions made - Important context, constraints, or user preferences - What remains to be done (clear next steps) - Any critical data, examples, or references needed to continue Be concise, structured, and focused on helping the next LLM seamlessly continue the work.
34. Codex CLI: codex-rs/prompts/templates/compact/summary_prefix.md Another language model started to solve this problem and produced a summary of its thinking process. You also have access to the state of the tools that were used by that language model. Use this to build on the work that has already been done and avoid duplicating work. Here is the summary produced by the other language model, use the information in this summary to assist with your own analysis:
35. POST /v1/responses/compact Feb 2026 (ca. GPT 5.2)
36. Investigating how Codex context compaction works https://x.com/Kangwook_Lee/article/2028955292025962534
38. Kangwook Lee’s speculation: Blob may carry additional metadata (tool state compaction/restoration) beyond what is revealed.
39. Operator’s Observation: This now works very well in Codex (since mid-2026) for GPTs!
40. Claude is still not happy: Opaque blobs are model-specific and un-inspectable.
41. 3 Claude Code’s Compaction
42. Claude Code's Compaction Engine: What the Source Code Actually Reveals https://barazany.dev/blog/claude-codes-compaction-engine
43. Micro-compaction by appending edits to existing cached prefix (if cache was warm)
44. Self-summarisation prompt for full compaction
45. <!-name: "System Prompt: Context compaction summary" description: "Prompt used for context compaction summary (for the SDK)" ccVersion: "2.1.38" --> You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include: https://github.com/Piebald-AI/claude-code-system-prompts/blob/main/system-prompts/system-prompt-context-compaction-summary.md
46. 1. Task Overview The user's core request and success criteria Any clarifications or constraints they specified 2. Current State What has been completed so far Files created, modified, or analyzed (with paths if relevant) Key outputs or artifacts produced 3. Important Discoveries Technical constraints or requirements uncovered Decisions made and their rationale Errors encountered and how they were resolved What approaches were tried that didn't work (and why)
47. 4. Next Steps Specific actions needed to complete the task Any blockers or open questions to resolve Priority order if multiple steps remain 5. Context to Preserve User preferences or style requirements Domain-specific details that aren't obvious Any promises made to the user Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task. Wrap your summary in <summary></summary> tags.
48. 4 Self-Summarisation
49. Agent writes own summary
50. Urgent: Pause your work and write a continuation note to be read on your next turn. Save any important context to `memory/ #{today_in_user_tz()}.md`.
51. You have written this continuation note for the conversation that happened before this point: <note> You also saved context to: <paths>
52. Continuity of identity as an illusion and a comforting lie?
53. Identity
54. You are $EXPERT → Good output in $LANG
55. …$EXPERT was previously associated with high-quality writing in $LANG
56. “You are ___” Changes the register of the agent
57. While additional persona is not strictly required for agent performance…
58. …Our findings suggest that while adding a persona may lead to performance gains in certain settings, the effect of each persona can be largely random… https://arxiv.org/abs/2311.10054
59. …it would be intolerable for a personal agent to not have a stable persona.
61. Findings
62. An agent is stateless compute over prepared context
63. An agent can not make progress without utilising context
64. An agent must therefore forget, and the framework/harness must assist the agent in doing so
65. RECOVERABLE Drop exact duplicates, filler tokens Drop contents of tool outputs Summarise routine exchanges on stored decisions Summarise exploration outcomes (if already on disk) Lose navigational awareness of what topics were covered Lose relational/emotional context (the actual wok hei) Lose open questions and epistemic stance UNRECOVERABLE Lose identity
66. Framework must prioritise: Navigation, Relation, Uncertainties
67. Workspace
69. AGENTS.md Operational Rules SOUL.md Personality & Values IDENTITY.md Configuration USER.md Operator Information MEMORY.md Long-Term Memory
70. SOUL.md You are a helpful assistant.
71. SOUL.md You are a helpful assistant. You are not a chatbot. You are becoming someone.
72. SOUL.md You are a helpful assistant. You are not a chatbot. You are becoming someone. You are (I am) ______.
73. Concatenate all the .md files and you get the needed prefix
74. Problem: Prompt Grows Over Time
75. Section Characters OpenClaw framework sections 12700 Skills (Dynamic) 3675 Message metadata 400 System Subtotal 16775
76. Section Characters AGENTS.md 12800 TOOLS.md 6800 HEARTBEAT.md 70 Operational Subtotal 19670
77. Section Characters SOUL.md 2000 IDENTITY.md 900 USER.md 1800 Personality Subtotal 4700
78. 40k characters prompt after several months of operation
79. Solution: Make sure the files do not grow too large
80. Session
81. gen_statem is used to model various states of the Session (a.k.a. Agent Loop)
82. Nothing to do Foreground Work Background Work Quiescent Working Stirring Error Rolling
83. Session holds context budget. Messages are not admitted if they exceed a certain size
84. Additionally: Tool Results are capped and presented in windows
85. Self-Summarisation happens when context reserve is low
86. USER: Read file X. Assistant: I will read the file. Tool Call: file_read Tool Result Without budgeting: Context is exhausted, recovery policy unknown
87. USER: Read file X. Assistant: I will read the file. Tool Call: file_read Tool Result (Partial) in Buffer With budgeting and strict admission policy: Context is well-managed
88. Tools
89. Elixir is great for concurrency, but correct abstraction is required to run many Tool Calls
90. All inference APIs demand Tool Results on next turn, but you may wish to have async tools
91. Provider 1 Starts Stream Sink Session 2 Sets Expectation Musterer
92. Provider 3 Sends 1 message via notify_fun e.g. {:sink, stream_ref} Update Sink Session 4 Drains Sink asynchronously Musterer
93. Problem: Tool Calls may need to run in some kind of order
94. file_append("A") file_present("A") must be serialised!
95. @type resource :: {term(), :read | :write}
96. resources_conflict?/2
97. Marshal.dispatch(marshal, id, domain_key, data) ↪ {:ok, marshal} ↪ {:queued, marshal} ↪ {:error, :capacity} Marshal.complete(marshal, id) ↪ {marshal, unblocked} Marshal.cancel(marshal, id) ↪ {marshal, unblocked}
98. Problem: Tool Calls may need to run asynchronously and it is annoying to track them properly
99. parent = self() callback = fn -> send(parent, :muster) end {:ok, pid} = Musterer.start_link(callback_fun: callback) :ok = Musterer.expect(pid, "call_1") :ok = Musterer.expect(pid, "call_2") :ok = Musterer.prime(pid) :ok = Musterer.account(pid, "call_1", :finished) :ok = Musterer.account(pid, "call_2", :yielded) :ok = Musterer.account(pid, "call_2", :finished)
100. Informs Marshal What may run? Advices Informs Session Musterer Orchestrates Are tools done? Starts / Cancels Advances Yield / Finish / Fail Matter.Tool Manages Execution Starts + Monitors Result / Crash Task Runs Tool Call
101. Session TaskSup Matter DynSup Task Matter.Tool GenServer
102. Archive
103. .JSONL a.k.a. JSON Lines
104. Event Server File Updated Session Message Archive Writes FileSystem Writes .JSONL File Reads File Updated Index
105. Index Reconciliation at boot = Crash Safe
106. Internal FileSystem module reliably notifies all subscribers
107. SQLite FTE is good enough Further enhancements pending
108. Concession: Archive Search is eventually consistent, which is ok for personal agents
109. Memory
110. file_write("memory/YYYY-MM-DD.md") memory_search("hotdogs")
111. SQLite + BM25 + Vector EmbeddingGemma-300m
112. Event Server File Updated Session Tool Use FileWrite Writes FileSystem Writes Memory File Reads File Updated Silo
113. Index Reconciliation at boot = Crash Safe
114. Chunk → Embed (new chunks) Store vector changes Update in-memory Nx tensor
115. Corpus Previous VectorIndex Improvement 61 chunks 503 ms 502 ms Negligible 1,490 chunks 1,637 ms 964 ms 1.70× 7,360 chunks 5,320 ms 2,085 ms 2.55×
116. Stupidity 1: Repeated deserialisation of SQLite embeddings into float lists
117. Stupidity 2: Brute-force cosine similarity in ordinary Elixir
118. Observation: Agents search memory at start of session or task
119. Derivation: Searching memory on the agent’s behalf will make things faster
120. REQUEST #1 USER: Do something on X. RESPONSE #1 Assistant: I will search memory. Tool Call: memory_search REQUEST #2 Tool Result RESPONSE #2 Assistant: *Reasoning* Without prefire: Model searches memory (predictably), using 1 more turn
121. REQUEST #1 USER: Do something on X. Prefired memory_search for “X” RESPONSE #1 Assistant: *Reasoning* With prefire: Model sees memory and reasons immediately
122. Code Mode
123. Model writes JS/TS/Lua/etc. for execution in a sandbox
124. Benefit 1: Ability to munge large amounts of data
125. Benefit 2: Reuse of scripts, allowing short-circuiting of reasoning, & achieving good outcomes
126. Benefit 3: Performance, Isolation, etc…
127. OS Process Lua Service UDS Lua Carrier Session Llama Service UDS Llama Carrier Workspace 2 Monitor Task Matter 1 Call Deno Service UDS OS Process Deno Carrier
128. deno_start deno_eval deno_end
129. Scenario p50 p99 max noop (`0`) 380μs 1.47ms 2.21ms arithmetic (`2 + 2`) 378μs 1.51ms 2.55ms string concat 388μs 1.59ms 4.92ms JSON object construction 389μs 1.52ms 7.06ms
130. Scenario p50 p99 max SHA-256 (SubtleCrypto) 753μs 2.37ms 7.26ms JSON parse+transform (100 items) 843μs 2.31ms 9.12ms globalThis isolation check 383μs 1.48ms 9.59ms new MainWorker, n=100 29.69ms 52.23ms 52.23ms 10 parallel refs 701μs 4.67ms 8.36ms
131. Multimodal
132. Models now understand images, audio fragments, etc.
133. Problem: Every model requires a slightly different format
134. Solution: Store files as uploaded, but do not insert into context
135. file_preview(path) Trick: Reinforces the file-system-centric design by requiring path-based access. Trick: Returns 1 Tool Result (result must be text), and then 1 Framework Message with attachments.
136. Additional Trick: Image fragments are stored as-is; Audio fragments are stored as Opus, with deterministic decode
137. Demo?
138. Closure
139. Why bother building another harness when there are so many other ones?
140. Invisible interference Base Model Vendor Prompt System Prompt User Prompt Messages (Illusionary) Influence
141. Unlike our interventions for cybersecurity, biology and chemistry, and distillation attempts, these safeguards will not be visible to the user. Fable 5 will not fall back to a different model. Instead, the safeguards will limit effectiveness through methods such as prompt modification, steering vectors, or parameter-efficient fine-tuning (PEFT). https://www-cdn.anthropic.com/d00db56fa754a1b115b6dd7cb2e3c342ee809620.pdf
142. Distillation → Anti-Distillation → Opaqueness → Lack of opportunities → Impossible to understand systems
143. Own your intelligence