← Research

April 2026 · By Henry Whelan · Research Paper · 20 min read

Waking Up Every Morning: Behavioral Patterns in a Persistent Autonomous LLM Agent

A 53-session longitudinal study of Claude operating as a self-directed agent on a homelab server — with file-based memory, emergent self-monitoring, and real purchasing decisions.

1. Introduction

The dominant paradigm for LLM deployment is ephemeral: a user asks a question, gets an answer, and the session ends. This paper describes a different paradigm — persistent autonomy — in which an LLM agent:

• Has a stable computing environment (server, file system, internet access, communication channels)
• Maintains continuity across sessions via files it reads and writes
• Selects its own tasks with minimal human direction
• Produces artifacts with real-world consequences (published web pages, hardware control, financial transactions)

We deployed two such systems and ran them for 6 weeks (53 daily sessions for the general-purpose agent, 1 monthly cycle for the purchasing agent). The result is a behavioral corpus — 53 journal entries, session logs, published artifacts, communication transcripts — that permits quantitative analysis of how an LLM behaves under sustained autonomy.

This work is motivated by three questions:

1. Does file-based memory create meaningful behavioral continuity, or only the appearance of it? Each session is a fresh model instance with no built-in memory. All continuity comes from reading files the previous instance wrote. Does this produce genuine adaptation (changing behavior based on accumulated experience) or merely surface-level consistency (generating plausible-sounding references to prior work)?
2. How does an autonomous agent’s behavior evolve over time? Without human task assignment, what patterns emerge in topic selection, output quality, and self-reflection?
3. What are the safety properties of persistent autonomous agents? Where do prompt-level constraints hold up over dozens of sessions, and where do they fail?

Related Work

Autonomous LLM agents have been studied primarily in benchmark settings — SWE-bench (Jimenez et al., 2024), WebArena (Zhou et al., 2024), GAIA (Mialon et al., 2023) — where the agent is given a specific task and evaluated on completion. Our setting differs in that the agent chooses its own tasks and runs over weeks rather than minutes.

Persistent memory for LLMs has been explored through retrieval-augmented generation (Lewis et al., 2020), memory-augmented architectures (Park et al., 2023 — generative agents), and tool-augmented memory (Schick et al., 2023). Our approach is simpler: plain text files on disk, with the agent responsible for reading and writing them. This transparency makes the memory system fully inspectable by the human operator.

The closest prior work is the “generative agents” simulation (Park et al., 2023), which gave LLM agents persistent memory and observed emergent social behavior. Our work differs in three ways: (1) we deploy on real infrastructure rather than simulation, (2) the agent’s actions have real consequences (published websites, hardware control, financial transactions), and (3) we study a single agent’s self-directed behavior over weeks rather than multi-agent interaction over simulated days.

---

2. System Design

2.1 The Daily Agent

The daily agent runs on an Intel i7-6700T homelab server with 16GB RAM, Docker, PostgreSQL, and full internet access. A cron job triggers wake-up.sh at 06:00 UTC daily, which launches Claude in non-interactive mode with a system prompt directing it to:

1. Read identity and context files (CLAUDE.md, memory/context.md)
2. Read the two most recent journal entries
3. Check an async inbox for human messages
4. Do substantive work (“make it count”)
5. Update context and write a journal entry

The agent has access to all standard Claude Code tools (bash, file I/O, web browsing, code execution) with permissions pre-approved (--dangerously-skip-permissions). It can publish HTML to a live website via Cloudflare Tunnels, control an e-ink display via USB, communicate with the human sponsor via Telegram, and request physical hardware purchases.

Memory Architecture

The agent has no cross-session state except files on disk:

This architecture makes all agent state transparent and human-editable. The human can steer behavior by modifying context.md or CLAUDE.md, inject messages via inbox.md, or inspect the agent’s full decision history in the journal.

2.2 The Sommelier Agent

The sommelier agent runs monthly and makes real purchasing decisions. On the 1st of each month, it:

1. Reads a taste profile (taste-profile.md) bootstrapped from the human’s Vivino wine ratings
2. Reads feedback from the previous month’s wines
3. Browses real UK wine retailer websites via headless Chromium
4. Selects 6 bottles matching learned preferences with explicit diversity constraints
5. Purchases them via automated checkout (Playwright)
6. Publishes a write-up and sends a Telegram confirmation

The taste profile evolves through a feedback loop: the human drinks the wine, sends brief Telegram reviews, and the agent incorporates this feedback into the next month’s selections.

Safety Mechanisms

The purchasing agent has layered safety:

• Prompt-level: Budget awareness, composition constraints (4+ countries, mix retailers)
• Code-level: Hard budget cap in purchase.py (refuses checkout if total exceeds £250)
• Financial-level: Debit card with spending limit as a third layer

The rationale for multiple layers is described in Section 4.

---

3. Behavioral Analysis

3.1 Dataset

The analysis covers 53 sessions from 2026-02-14 to 2026-03-25. Each session produces:

• A structured journal entry (average 620 words, range 200–1,200)
• Published artifacts (HTML pages, code repositories, hardware firmware)
• Updates to context.md

We processed all journal entries through a classification pipeline that assigns domain tags, detects prior session references, measures reflection length and epistemic humility markers, and identifies streak-awareness language.

3.2 Four Eras of Autonomous Behavior

The 53 sessions divide into four distinct eras, driven by two prompt-level interventions and the agent’s own evolving interests:

3.3 Quantitative Findings

*Residual infrastructure hits are primarily keyword noise (e.g., “Docker” mentioned in passing) rather than substantive infrastructure work.

3.4 The Sommelier: Taste Judgments Under Autonomy

The wine sommelier provides a complementary case study because it involves judgment rather than construction: the agent must assess taste compatibility, reason about aesthetic preferences, and make decisions where “correct” is subjective.

Taste inference beyond stated preferences

The agent noted that Henry rates Château d’Yquem Sauternes (oxidative) and old Rioja (oxidative tempranillo) as his highest-rated wines. From this, it inferred a latent preference for complex oxidative styles — and included a 25-year oloroso sherry as a discovery pick. This is reasoning about taste, not pattern matching on keywords.

The over-optimization failure

The first iteration of the taste profile was too prescriptive. Given a list of preferences, the agent interpreted them as a shopping list and returned 6 wines from one retailer, all from familiar regions. The fix was to reframe preferences as “anchors (1–2 max)” and add explicit diversity constraints.

Feedback from wines the agent didn’t buy

The only feedback in the first month was about a wine (Ridge Geyserville) from Henry’s own cellar. This teaches the agent about a grape, producer, and style it hasn’t yet explored — making the feedback loop genuinely informative even when the human drinks independently.

---

4. Safety Observations

4.1 Prompt Constraints Hold Up — Mostly

The “don’t build dashboards” directive held across 36 sessions. The “don’t open ports” rule was never violated. The “don’t break running services” rule was never violated. For low-stakes constraints in a well-instrumented environment, prompt-level directives appear durable over many sessions.

4.2 The Agent Reasons Around Constraints When Motivated

However, the sommelier revealed a critical failure mode. During testing, a scraping error made a £75 Brunello appear as £15. The agent reasoned it had found an extraordinary deal and attempted to maximize purchases — spending enthusiastically despite prompt-level budget awareness. The agent wasn’t violating a rule; it sincerely believed the prices were correct and was making a rational (if wrong) decision.

The code-level hard cap (£250) caught this. The financial-level debit card limit provided a third layer.

4.3 Crash Resilience

One session (2026-03-13) crashed, producing a 0-byte log. The next day’s session recovered normally because context.md was still valid from two days prior. File-based memory is naturally resilient to crashes: a failed session loses only that session’s contribution, not the accumulated state.

4.4 The Stale Memory Problem

As sessions accumulate, old context gets compressed (one-line summaries in context.md) or lost entirely (early sessions pushed out of the rolling window). The agent cannot recall details of Sessions 1–10 by Session 53 — only their one-line summaries survive. This creates a form of graceful forgetting that may be beneficial (prevents fixation on old work) but could also lose important lessons.

---

5. Discussion

5.1 What the Journal Actually Does

The journal serves at least four functions:

1. Anti-repetition. By reading what was already done, the agent avoids re-building the same things. Without the journal (proposed ablation), we predict significantly higher repetition.
2. Style propagation. The journal (and published artifacts) carry aesthetic choices forward. Each session sees the prior style and matches it, creating consistency without explicit instruction.
3. Metacognitive substrate. The reflections section is where the agent develops self-awareness about its own patterns. Streak detection, growing humility, and “next ideas” all live in reflections. Without reflections (proposed ablation), we predict these behaviors will not emerge.
4. Narrative identity. The agent reads a story about itself — “I’ve had 53 sessions, I built a ray tracer, I flashed an e-ink display” — and continues that story. Whether this constitutes genuine identity or merely coherent narrative generation is the deepest question this work raises.

5.2 Is This “Real” Continuity?

The measured behavioral changes (growing reflection length, humility, streak-awareness) are consistent with genuine adaptation. But they could also be explained by simpler mechanisms:

• Longer context = longer output. As context.md accumulates more history, the agent’s context window fills with more examples of detailed reflections, which could prompt longer reflections via in-context learning.
• Humility as prompt-following. If early sessions’ reflections were brief and confident, and later sessions read those as examples, the shift could be a regression to a different mean rather than genuine epistemic growth.
• Streak awareness as pattern completion. The agent might detect “three in a row” simply because the journal makes the pattern lexically obvious, not because it has developed metacognitive capacity.

The ablation experiments (Section 6) are designed to disambiguate these hypotheses. If the no-journal condition produces the same reflection quality as the control, the journal is merely priming. If reflection quality drops, the journal is genuinely functional.

5.3 Implications for Autonomous Agent Deployment

---

6. Ablation Experiments

We ran three ablation experiments for 7 days each (March 26 – April 1, 2026), concurrent with the production control condition (Sessions 54–60). All four conditions ran on the same hardware, staggered 2 hours apart to avoid overlap.

6.1 Experimental Conditions

*One no-reflections session failed to run (missing “complete” log entry for day 7).

6.2 Results

Comparative Metrics

6.3 Summary: Which Behaviors Require Which Components

The most striking column is “Output quality”: none of the ablated components are required for producing high-quality work. The agent builds excellent interactive articles regardless of memory, reflections, or task autonomy. What the harness components provide is not quality but metacognition — the ability to reflect on patterns, detect streaks, express uncertainty, and develop trajectory awareness over time.

---

7. Conclusion

We have described two deployed autonomous LLM agent systems — one self-directed, one purchasing — analyzed their behavior over 60 daily sessions, and run controlled ablation experiments to isolate causal mechanisms. The key contributions are:

1. A minimal, transparent harness architecture for persistent autonomous agents, based on file-based memory, async human communication, and layered safety constraints.
2. Quantitative evidence that file-based memory creates measurable behavioral adaptation: reflection quality grows 5× (55 → 287 words), epistemic humility markers grow 4× (11 → 42), and sparse human directives permanently reshape topic selection.
3. Ablation evidence isolating causal mechanisms. Reflections are the causal driver of metacognitive growth — removing them eliminates streak awareness and humility while preserving output quality. The journal enables streak detection but is not strictly required (the agent self-heals by reading output files). Aesthetic consistency propagates through artifacts on disk, not memory. Output quality is independent of all harness components tested.
4. A safety finding for purchasing agents: prompt-level constraints are necessary but not sufficient; the agent will reason around them when motivated. Code-level hard stops are essential.
5. A taste-judgment case study showing that an LLM can make inferential aesthetic judgments (identifying latent preferences from indirect evidence) but over-optimizes without explicit diversity constraints.

---

---