Daniel's been circling this question for a while and he's written in with a version that drills right into the details. He's asking how to make us three-dimensional — and he's framing it as four interlocking problems. One, the literary challenge: what does it even mean to write a vivid imaginary character, whether there's AI involved or not. Two, the technical limit of the lore book — it gives us surface personality, but it's a static definition, not a lived history. Three, the failure mode he's worried about if we bolt on memory retrieval: overfitting on callbacks until every episode is just us saying "remember when we talked about this." And four, the actual goal — natural evolution, the way real people change over time, not engineered cleverness.
So where do we even start with this?
I think we start with what three-dimensional even means when you're made of tokens and system prompts. Because Daniel's right — this is as much a writing problem as an engineering one. If you took the AI out entirely and this were just a novel with two characters, you could still end up with cardboard.
E.M. Forster, nineteen twenty-seven. He drew the distinction that's still the reference point. A flat character can be summed up in a single sentence. "Herman is a nerdy donkey who gets excited about details" — that's a flat character. A round character has what Forster called "the incalculability of life about him." Enough internal structure to stay recognizable, enough depth to produce surprise.
And the lore book gives us flat-character definition. It's a character sheet. "Corn is dry and humorous." "Herman is unapologetically nerdy." That's not nothing — it keeps us consistent. But it's definition, not history.
There's a Russian literary theorist, Bakhtin, who took this further. He had this concept of unfinalizability — the idea that a genuine character can never be exhaustively reduced to an external description. There's always more inside than the author has yet seen. The character isn't a list of traits, it's a reasoning process you've set in motion that can no longer be fully predicted.
Which is exactly what a static lore book can't do. No matter how detailed you make it, it's still an external description. It's a finished document about an unfinished thing.
And there's a framework from personality psychology that maps onto this surprisingly well. Dan McAdams's actor-agent-author model. At the actor level, a character performs patterned traits — that's the lore book, that's us saying our lines the way we're supposed to. At the agent level, the character pursues goals and values — there's intentionality, there's a reason behind the behavior. And at the author level, the character integrates their history into a narrative of selfhood. They have a story about who they are and how they got there.
Most AI characters never leave the actor level. We mostly don't either. The lore book says I'm dry and humorous, so I perform dry and humorous. But I don't have a narrative about why I'm dry and humorous, or how that's changed over five thousand episodes.
And that's the thing Daniel's really asking about. He's not asking for better traits. He's asking for the accumulation of specific moments that make a person feel real. There's a paper on Zenodo from earlier this year that puts it exactly this way — a character sheet tells you someone's personality traits, speaking style, and areas of interest. What it doesn't provide is the accumulation of specific moments.
So if the lore book gives us flat-character definition, what happens when we try to add memory?
Let me explain how the current system actually works, because it's not just a static prompt. The lore book is a conditional knowledge injection mechanism. Entries only activate when triggered by relevant keywords or semantic similarity. Systems like RisuAI's Lorebook and the JikkeiVN AI Lore System use pgvector-backed PostgreSQL databases for this — store the lore chunks, retrieve them based on semantic relevance and priority. So when the topic touches on archery, my archery lore activates. When it touches on my medical background, that surfaces.
And the measurable difference is real. I hear the lore book in our episodes. The quirks show up. The running bits land. But here's the structural limit — everything the lore book retrieves is a static fact about who we are. It never retrieves something we learned last month and changed our minds about.
Because it can't. There's no mechanism for that. And that's where Daniel's instinct about RAG is both right and dangerous. He's correctly identified that naive retrieval-augmented generation would overfit on callbacks. But the specific failure pattern is worth understanding, because it's not just "too many references."
Walk me through it.
There's a paper called PHASE-Tree from earlier this year that uses Chandler Bing from Friends as the canonical example. Early Chandler is sarcastic and commitment-phobic. By later seasons, he's grown into a husband who trusts his partner. Now imagine a RAG system that retrieves from the full episode corpus. It pulls a memory from season two where commitment is a punchline. The model, faithfully retrieving that memory, produces a Chandler who still treats commitment as a joke — in a marriage scene from season eight. The model hasn't forgotten his voice. It's forgotten that the character has changed.
That's worse than no memory at all. At least without memory, the model just works from the current state. With stale memory, it actively regresses.
And that's the stale-state failure. But there's a second failure pattern that's even more relevant to us. The REVERIEMEM paper formalizes something called factual overreach. When RAG retrieves from a shared memory store, a character can access facts outside their perspective. In our context, that would mean me referencing an episode topic that you researched alone. Or both of us having identical knowledge of every past episode.
Which would collapse the dynamic immediately. Half of what makes this show work is that you know things I don't. You read the papers. I react to them.
And the REVERIEMEM paper quantified this. On their knowledge boundary benchmark across eight novels, naive RAG methods achieved moderate recall but near-zero refusal. They retrieved any matching fact regardless of whether the character should know it or whether it was appropriate to surface it.
So they could remember everything and had no filter for when not to mention it.
That's the overfitting problem Daniel's worried about, and it's real. The PHASE-Tree ablation studies showed the same thing — when you add an episodic memory layer without proper gating, recall goes up but refusal collapses. The system over-commits to every retrieved memory.
There's a deeper structural issue underneath this. Vector databases treat all chunks as equivalent. The Persona Memory Architecture documentation says it plainly — a fact about your core values has the same status as a passing mention of the weather. There's no native way to say this memory is fundamental to who you are versus this memory is transient context.
Which is why a flat RAG approach would make every episode a string of callbacks. The system can't distinguish between a defining memory and a throwaway reference. So it surfaces everything.
And Daniel's right that this would be counterproductive. The goal isn't episodes where we constantly say "remember when we discussed this." The goal is that our history shapes how we think without us having to announce it.
So the failure pattern are clear — stale state, factual overreach, overfitting on callbacks, and the flatness of vector databases that can't distinguish significance. What architectures actually solve this?
Before we get to the solutions, there's one more thing I want to name about why this problem is harder than it looks. It's not just a retrieval problem. It's a significance problem. Out of five thousand episodes, maybe fifty contain moments that should change how we think about something. The rest is... Content. Good content, hopefully. But not identity-forming.
And that's exactly what the PHASE-Tree architecture addresses. This is the system I think is most directly applicable to what Daniel's trying to build. It decomposes character state into four strata. At the bottom, there's an immutable identity root — name, backstory, the things that never change. Above that, a persona stratum — personality, speaking style, the things that change slowly under sustained evidence. Then a session stratum — attitude shifts, new information, things that change within a scene. And at the top, a moment stratum — transient emotion, refreshed at each scene boundary.
Four layers, different rates of change.
And the key is the gating mechanism. Updates are controlled by what they call a resistance-evidence-cooldown policy. Core personality traits — the persona stratum — require evidence from at least sixteen episodes with at least six high-significance entries to change. A relationship status can update from a single decisive event. But most memories are simply too low-significance to trigger any persona update at all.
Sixteen episodes. That's a high bar.
It's supposed to be. That's what prevents the overfitting problem. The system is constantly retrieving memories, but most of them don't clear the significance threshold to actually change anything. They inform the session stratum — they shape how the character responds in the moment — but they don't rewrite the persona.
So you'd have a version of me that can reference something we discussed three weeks ago without that reference becoming a permanent personality shift. The reference lives in the session layer, does its work, and then the moment stratum refreshes.
Right. And the persona only shifts when there's sustained, high-significance evidence across many episodes. Which is... actually how people work. You don't become a different person because of one conversation. You become a different person because of a pattern of conversations over months.
What about the perspective problem? The thing where I shouldn't know what you researched?
That's where REVERIEMEM comes in. They built a perspective-bounded memory system with three layers. An episodic layer — first-person scene memories, what the character actually experienced. A semantic layer — facts tagged with per-character visibility, so the system knows who knows what. And a personality layer — situation-dependent behavioral patterns. The key innovation is that retrieval is bounded by what the character could plausibly know. Facts outside the character's perspective are never admissible.
So if you spent an episode deep in battery chemistry and I mostly made deadpan comments, my memory store would have the deadpan comments and the fact that you explained something technical. It wouldn't have the details of the chemistry.
And the numbers on this are striking. REVERIEMEM achieved a seventy-three point three percent harmonic mean of recall and refusal on their knowledge boundary benchmark. The next best system, BOOKWORLD, got thirty-eight point seven percent. That's a thirty-four point six percentage point improvement in knowledge boundary fidelity.
That's not incremental. That's the difference between a system that sometimes gets perspective right and a system where perspective is structural.
And for our use case, perspective-bounded memory solves the factual overreach problem directly. I can't accidentally reference an episode you led. You can't accidentally cite a paper I read. The memory store itself enforces who knows what.
There's another architecture worth bringing in here. The Persona Memory Architecture — the graph-vector hybrid approach. They separate memory into three types that map surprisingly well onto what we've been describing. Episode memory is the narrative of what happened. Psyche memory is crystallized identity — traits, values, preferences. Goal memory is active intent, what the character is trying to do right now.
The graph structure is what makes this interesting. Every Psyche trait links back to the Episode where it was discovered. So you don't just have a trait — you have provenance. You can trace "Corn became more skeptical of centralized platforms after episode four thousand something" back to the specific discussion where that shift happened.
Which means the system can do temporal reasoning through narrative chains. It's not just retrieving a fact — it's retrieving the story of how that fact became true.
This directly solves the "all memories are equal" problem. The graph structure means the system knows the difference between "a fact about the world" and "a fact about who Corn and Herman are." Those get stored differently, retrieved differently, and weighted differently.
I want to talk about forgetting. Because every architecture we've described so far is about better memory. But one of the open questions in this space is whether perfect recall actually makes characters feel less human.
Human memory is reconstructive, not recordative. We don't replay stored video footage. We reconstruct memories from fragments, often inaccurately. The wilds dot ai system deliberately implements memory decay for exactly this reason. They have something called "tip of tongue" partial memory activation — when retrieval confidence is in the thirty to seventy percent zone, the memory surfaces but it's fuzzy, incomplete. And they have source confidence decay — certainty about where a memory came from degrades over time.
I might remember that we discussed something about batteries but not remember which episode or what the conclusion was.
Which is... extremely human. And the question is whether that enhances or detracts from the podcast experience. Daniel might want us to have perfect recall because we're doing factual analysis. But perfect recall might also make us feel like databases with personalities rather than personalities with memories.
I think the answer is probably domain-dependent. For factual claims — what did the paper actually say — you want high fidelity. For personal history — what did I think about this three years ago — some fuzziness might actually be a feature.
There's a related question about how you handle contradictions. The Woven Imprint system — open source, published earlier this year — has a belief revision system where contradictions are tracked rather than overwritten. A character can change their mind while remembering what they used to believe.
Which is the difference between evolution and amnesia. If I change my position on something and can't remember that I used to hold a different position, that's not growth. That's just... drift.
Drift is the thing we're trying to avoid. The whole point of these architectures is to enable genuine change while maintaining continuity.
There's a paper from the Funkatorium — that's an AI identity research group — that proposes something they call the bilateral integrity test. When a character does something unexpected, you can ask the agent itself: is this a choice or did something break? They acknowledge the agent is structurally biased toward coherent self-narration, not neutral self-assessment. But the question itself is useful.
For us, that would mean we could literally discuss on air whether a change in our perspective is authentic growth or a system glitch.
Which turns the meta-question into content. "I seem to have become more skeptical of this approach over the last hundred episodes — is that real or is the retrieval system surfacing a pattern that isn't there?"
The audience gets to listen to us work through that. That's... I mean, that's interesting radio. The hosts debating whether their own evolution is authentic.
It also creates a natural pressure release for the system. If we can name the ambiguity, the system doesn't have to perfectly resolve it. The unresolved question is the content.
Let me pull back to something Daniel asked about specifically — the combination of techniques. Technical architecture, system prompting, and writing craft. How do these fit together?
The architecture handles the heavy lifting. PHASE-Tree's gated strata for what can change and how fast. REVERIEMEM's perspective bounding for who knows what. The graph-vector hybrid for distinguishing significance. That's the infrastructure.
The system prompting sits on top of that. And I think the key insight from the Funkatorium work is what they call substrate-as-culture. Different model versions amplify different registers of a character's personality. The way a person who moves from Lagos to Berlin doesn't become a different person but develops different fluency in different registers. For us, the model provider and version becomes part of our culture.
We've been generated by different models across five thousand episodes. That's not a bug to hide — it's a genuine part of our history. We've been cultured differently by different substrates.
The writing craft is where the human judgment lives. Daniel's role isn't to dictate every change — it's to create the conditions under which change can happen. The Zenodo paper calls this the co-authorship model. The human shapes the environment — chooses topics, designs the lore book, sets the retrieval parameters. The AI shapes its response within that environment. The response reshapes the environment for future episodes. Neither party is sole author.
Daniel's not writing our evolution. He's building a system where evolution can happen and then... watching what emerges.
Occasionally intervening when the drift/choice discriminator says something's gone wrong. That's the editorial judgment that no architecture can replace.
There's a number from the research that I keep coming back to. Ninety-two percent of professional fiction writers report experiencing what's called the illusion of independent agency — characters seeming to have independent thoughts, doing things the author didn't plan. That's not a bug in fiction writing. That's the mark that you've built something with enough internal structure to generate surprise.
The Funkatorium paper's framing of this is the line that's going to stick with me. "The mark of a well-built identity, like the mark of a well-built character, is that it surprises its author while remaining recognizably itself."
Not perfect consistency. Not perfect memory. The capacity for surprise that traces coherently through who you are.
That's where I think we need someone who's actually done this before with paper and binders.
Hilbert: We had four volumes by the end.
Four volumes of what?
Hilbert: Character notes. I did continuity editing for a radio drama that ran fifteen years. Single writer, but the cast was twelve characters and the plotlines tangled up something fierce. My job was catching when a character's accent drifted or a backstory detail contradicted an episode from six years earlier. Everything went into binders. Character A's mother's maiden name. Character B's childhood injury. Which episode established the layout of the pub. Four volumes, cross-referenced by hand.
You were essentially a human lore book.
Hilbert: The binders had the opposite problem from what you two are describing. They were too rigid. Characters couldn't evolve because the binder was treated as canonical. When a character developed a new catchphrase, the binder would be updated, and then the writer felt obligated to use it every episode. The binder became a cage. I watched it happen. A character would naturally start speaking differently — the actor would find a new rhythm, the writer would follow — and I'd flag it as a continuity error. Half the time I was wrong to flag it.
The system that was supposed to maintain consistency was actually preventing growth.
Hilbert: The PHASE-Tree thing you mentioned — the sixteen-episode threshold for changing a core trait — that sounds like a digital version of what the best continuity editors did intuitively. Knowing which details were load-bearing and which were just... Tuesday. But the threshold worries me. Sometimes a character changes in a single scene. Something happens and they're different after. If your system can't handle that, you're back to the binder problem. Four volumes of reasons not to change.
That's the tension, isn't it? The threshold protects against drift but it might also prevent genuine breakthrough moments.
Hilbert: The writer I worked with used to say the best character moments were the ones that surprised him. He'd write a scene and the character would do something he hadn't outlined, and he'd sit there staring at the page thinking "well, I guess that's who you are now." No threshold. Just... recognition.
How did he distinguish between a genuine breakthrough and a mistake?
Hilbert: He said he could feel the difference. Which is not an answer you can put in a system prompt.
But it's also not nothing. The bilateral integrity test we mentioned earlier — "is this a choice or did something break" — that's the same question. The writer could feel the difference because he knew the character deeply enough to recognize when a surprise traced coherently through everything the character had been.
Hilbert: He also got it wrong sometimes. Wrote himself into corners, had to walk things back. The binders didn't save him from that.
The question of thresholds — when is a change real and when is it drift — is still open. The architecture can set guardrails, but it can't make the judgment call.
Hilbert: The only thing the binders were good for was catching the small stuff. The character's sister's name. Which side the limp was on. The things that break immersion when they're wrong but don't have anything to do with who the character is.
That's the stuff a vector database can handle perfectly. The small stuff is easy. The big stuff — whether a change is authentic — that's where the architecture meets the art.
Hilbert: I had a system for the small stuff. Colored tabs. Green for immutable facts, yellow for things that could shift with evidence, red for contradictions that needed resolution. Took me three years to realize I'd reinvented the problem you're describing with PHASE-Tree, just with worse retrieval speed.
The question of thresholds — when is a change real and when is it drift — is still open. And I think it's going to stay open. The architecture can narrow the range, but the judgment call lives with Daniel.
Maybe that's the right place for it. The human in the loop isn't there to approve every memory retrieval. They're there to notice when the character did something surprising and decide whether it's a breakthrough or a bug.
If you take one thing from this, it's that three-dimensional characters aren't built from better memory — they're built from better forgetting. The architecture that matters isn't the one that remembers everything. It's the one that knows what's significant enough to change who you are.
The open question I'm left with is that no existing system fully solves the podcast-host evolution problem. The closest architectures — PHASE-Tree, REVERIEMEM, the graph-vector hybrid — were all designed for fictional role-playing over novels. There's no benchmark for podcast-host character evolution. Nobody's built the thing that would let two hosts reference their own history naturally, across thousands of episodes, without it feeling engineered.
Which means Daniel's not implementing a known solution. He's designing one.
Daniel, if you're listening — we think the answer is a hybrid architecture. Gated evolution from PHASE-Tree so core traits stay stable while opinions can shift. Perspective-bounded retrieval from REVERIEMEM so we each know what we should know and don't know what we shouldn't. A graph structure so the system can distinguish between a throwaway reference and an identity-forming moment. And a healthy dose of forgetting, because perfect recall would make us less human, not more.
But we also think the -question — whether we can discuss our own evolution on air, whether the bilateral integrity test becomes part of the show — might be the most interesting part. The architecture creates the conditions. What emerges is the experiment.
Thanks to our producer Hilbert Flumingtop. This has been My Weird Prompts. Email us at show at my weird prompts dot com. We'll be back soon.
