Sketch.
Built · AI agents

Zinnia and Little Susie: personal AI agents

Overview

Two agent systems built in n8n on local models. Zinnia is the assistant I use daily on Telegram for tasks, journaling and project notes. Little Susie is a controlled experiment in whether an agent can learn from experience without anyone editing its prompt.

Client
Personal projects
Discipline
AI Engineering + Product
Tools
n8nLM Studio (gpt-oss-20b)Postgres + pgvectorRedisTelegramBrave Search
Zinnia and Little Susie: personal AI agents

Impact overview

3specialist sub-workflows Zinnia calls as tools: tasks, journal and projects.
2evidence rules enforced in SQL so reflections cannot invent learning.
Local-firstboth agents run on local models; Zinnia keeps a hosted model only as a fallback.
01 — Introduction

Two agents, two different questions.

Zinnia asks: what does it take to make an AI assistant I can rely on every day? Little Susie asks: can an agent develop over time through recorded experience, in a way I can inspect and trust?

Both run in n8n on local models, talk through Telegram, and keep their state in Postgres and Redis.

02 — Problem

Agents are easy to demo and hard to trust.

  • Assistants claim they did things they did not do: “I logged that” with no journal call.
  • One agent with every tool gets confused about where things belong: a task, a journal entry, a lasting preference.
  • Memory that the model writes freely can drift, contradict itself or quietly overwrite what came before.
  • It is hard to tell whether an agent that “learns” is learning, or just agreeing with its last conversation.
03 — Goal

Reliable help, and inspectable learning.

For Zinnia: do real work (tasks, journal, project notes, search) and never claim an action that did not happen. For Little Susie: keep the model and prompt fixed, let only the recorded memory change, and make every change traceable to evidence.

04 — Solution: Zinnia

An orchestrator with specialist tools and a checker.

How Zinnia handles a messageThe orchestrator decides; sub-workflows do the work; a checker verifies.
  1. Telegram message Fast paths for journal and project commands; everything else goes to the agent
  2. Load memory Active long-term memories from Postgres are added to the prompt
  3. Orchestrator Local model with 20 messages of Redis chat memory and a tool set
  4. Tools Tasks, journal, projects, web search, calculator, job tracker
  5. Reply check Code and a judge model confirm claimed actions really ran
  6. Reply One retry at most, then an honest note if still wrong
  1. Clear lanes for memory

    The tool descriptions draw hard lines. Things that happened today go to the journal. Anything about a named project goes to the projects tool. Only lasting preferences and rules go to long-term memory. The quick test is written into the prompt: will this still be true next month and change how you work with him?

  2. A task manager sub-agent

    Tasks are handled by a separate agent that owns Google Tasks. It reads a goals table (maximum three active goals), routes each new task to a goal list, an inbox or an explore list, checks for duplicates, and re-reads the result to report where the task actually landed. If the destination is ambiguous it stops and asks.

  3. Reply checker

    After the agent answers, a code node compares what the reply claims against which tools actually ran, flagging things like “I logged that” with no journal call. A small judge model checks that the reply answers the message. A failure triggers one retry with the problem described. If it still fails, the reply gets an honest note instead of a false claim. Every verdict is logged. Trivial messages skip the model check to save time.

  4. Journal and projects, including this case study

    The journal sub-workflow logs and recalls entries and a nightly job writes the day’s page to my notes. The projects sub-workflow captures decisions, results and lessons as I work, asks follow-up questions on Sundays, and drafts a case study from the record when I ask.

05 — Solution: Little Susie

An experiment with the variables locked.

Little Susie is built as four connected workflows. The model, the system prompt and the retrieval settings are frozen and versioned in a database config. The only thing allowed to change is what she remembers.

  1. A: Live conversation

    A separate Telegram bot that accepts text from one authorised chat. It loads the fixed config, retrieves a limited set of relevant memory records, answers, stores the raw interaction in Postgres and hands it to the next stage. Memory reaches the model as labelled data below the system prompt, so it cannot rewrite the instructions.

  2. Retrieval

    A shared read-only sub-workflow runs a vector search (pgvector), then loads the authoritative active records from Postgres, so the same lookup serves live chat and evaluation.

  3. B: Experience processing

    Turns a finished interaction into a traceable experience with observations, or leaves it as an ordinary episode if nothing happened.

  4. C: Nightly reflection

    At 3 AM a model reviews new experiences against the patterns, lessons and principles already held. Most nights nothing should change, and a quiet night is recorded as a quiet night. The model proposes; SQL decides: IDs must exist, a pattern needs two observations, and lessons and principles need two supporting experiences, or they are discarded. Revisions never delete: the old wording goes to a revisions table with the reason and the evidence, and the version number goes up. The full model output is kept so dropped items stay visible.

  5. D: Evaluation

    A manual run answers a set of benchmark prompts twice, once as Little Susie with memory and once as an identical control without it, and logs both for blind scoring.

06 — Outcomes

What I got from building them.

  • A daily assistant that captures tasks, journal entries and project notes from one chat, with every claimed action verified.
  • A project record that feeds my case studies, so writing about work starts from notes taken while doing it.
  • A repeatable pattern for agent memory: propose with a model, validate with rules, store with history.
  • Local-first: both agents run on models on my own hardware. Little Susie never leaves it; Zinnia has a hosted model configured only as a fallback.
07 — Learnings

What I've learned.

  • Trust, but check: a second look at what the agent claimed catches the most common failure, saying it did something it did not.
  • Put rules where rules work. Evidence thresholds in SQL are more reliable than asking a model to be honest.
  • Keep experiments clean. Freezing the prompt and model turns “does it learn?” into a question you can actually test.
  • Separate lanes beat one smart agent: specialist sub-workflows with narrow tool descriptions route better than a single prompt full of rules.
08 — Future

What's next?

  • Run the Susie-versus-control evaluation and score it blind before drawing any conclusion.
  • Share a sanitized version of the reply-checker pattern as a download.
  • Add retention rules for the journal and interaction logs.
(virtually)

Let's grab a coffee.

If you have the time, I'd love to get to know you, your team, and what you have going on.

Set up a meet or email hello@alexandernicholas.me