A thread on V2EX asked a question a lot of us have quietly sat with: after Second Me, what are people actually using to build their own AI persona?
The open-source version has not shipped new code since last May, and the team moved on to a closed, hosted product. So the project is basically parked, and the original wish is still unmet.
The wish itself is small and specific. Feed in your own notes and chat history, get a stand-in that can reply in your place, that doesn't make things up, and ideally that sounds like you. That's it. Nobody in the thread was asking for a digital clone on stage. They wanted a reliable text persona grounded in their own material.
Why every existing option felt a little off
The original poster had already shopped around, and the shortlist reads like a map of the trade-offs. Distilly distills your chat logs into a skill you drop into Claude Code and keeps getting updates, but it has no voice and you can't hand it to someone else. WeClone fine-tunes a LoRA on your chat logs and mimics your tone well enough to hang off a personal WeChat account, but it doesn't care whether the facts are right, and every time you add new material you have to retrain. Delphi is the polished commercial version with a cloned voice, cheapest tier at $79 a month, and you can't self-host. Memory frameworks like mem0 and Letta are parts, not a persona. Digital-human tools like HeyGen handle looking and sounding like you, but you still have to supply every word they say.
So the complaint lands in one of three buckets: it fabricates, it needs a retrain, or you're renting someone else's service. That's a useful signal, because it tells you exactly which half of the problem is worth rebuilding and which half isn't.
The quiet technical verdict in the replies
One reply did the unglamorous work of reading the Second Me 2.0 paper, appendix and repo included, and the diagnosis is the most valuable thing in the whole thread. The headline numbers come from a single user with 132 notes and 62 todos, so the pretty table is a demo, not an experiment. There's no baseline against plain RAG or long context. When one metric looked bad, the authors declared the metric unreliable and swapped in human scoring. The project is real as open-source engineering, Apache-2.0 with a working extraction-to-training pipeline, but as research it reads like a pitch deck.
Underneath the critique sits the part that actually matters for anyone building. Baking memory into model weights, meaning per-user fine-tuning used as storage, is a disaster for write economics. Every new memory means a retrain, which means latency, cost, and catastrophic forgetting. The reply's point is that the industry already converged on retrieval plus layered text, the non-parametric route, not because nobody thought of parameterizing, but because people tried it and it wasn't worth it. Vector store plus structured text, no layer that trains your words into the weights.
That lines up neatly with the three complaints. The retrain pain is a direct consequence of the parametric approach. The fabrication problem is a consequence of letting the model answer from its own head instead of from retrieved passages. Both go away if you build the durable half the boring way.
The durable half, and the honest boundary
So let's split the wish in two. There's the retrieval-grounded persona that answers from your own text and stays current as you add files. And there's the voice, the cloned audio and the true style fine-tune that makes it sound like you at the phoneme level. The first half is buildable on confirmed VicroCode capabilities. The second half is not, and I'd rather say that plainly than quietly imply otherwise. Voice cloning and real style fine-tuning fall outside what the platform offers, so this is a text persona grounded in your material, not a sound-alike. If sounding like you is the non-negotiable, this isn't the tool for that part.
With the boundary drawn, here's the shape of the build.
Indexing your text as a knowledge base
Start by getting your notes and chat exports into a LanceDB knowledge base. You chunk the text, embed it, and store it, and from then on "adding material" means adding files to the index, not kicking off a training run. This is the step that kills the retrain treadmill. New notes become new retrievable passages, available immediately, and nothing about the model changes.
Keep a little structure alongside the vectors. A SQLite table that tracks source, date, and a short label per document gives you a way to filter and to show provenance later. File management on the platform handles the raw uploads, so your original exports stay as the source of truth and the index is derived from them.
The grounding gate
The answer logic lives in a Python backend, and the one rule that makes or breaks the whole thing is the grounding gate. You run Python online to take a question, retrieve the top passages from the knowledge base, and only then call a model from the Model Center to compose a reply strictly from what came back. If retrieval returns nothing relevant above your threshold, the honest response is "I don't have anything on that," not an improvised guess.
That gate is the entire answer to the "it fabricates" complaint. WeClone doesn't check whether the facts are right because its knowledge is smeared into weights with no notion of a source. Here, every reply is tied to retrieved passages, and you can return those passages next to the answer so the persona shows its work. Expose this as a hosted API endpoint with in-platform tool calls so the retrieval step and the model call stay in one place.
One caution worth stating up front: a persona that answers from your private notes should sit behind authentication before it's reachable by anyone but you. The build above doesn't include access control by default, and a grounded persona exposed to the open internet will happily serve your personal material to whoever finds the URL. Add an auth check at the endpoint before you share it.
Serving it and, if you want, sharing it
The front end is a plain HTML chat page, and web app hosting puts it online without you standing up a server. The page calls your endpoint, shows the reply, and shows the retrieved sources underneath. That source panel does double duty: it's a trust signal for you and it's the thing that lets you hand the persona to someone else without worrying it'll invent a quote.
And that last part answers the third complaint. Distilly couldn't be shared and Delphi couldn't be self-hosted, but a hosted page with its own endpoint can be published, shared, or monetized through the platform if that's where you want to take it. Whether a grounded-notes persona is genuinely useful to other people is unverified and entirely depends on your material, so I'd treat sharing as a later experiment, not a given.
What you actually get
Strip it down and the result is modest on purpose. A persona that answers in your words because it only ever speaks from your text, that stays current the moment you drop in a new file, and that lives on infrastructure you control rather than a subscription you rent. No retrain loop, because nothing is parameterized. No fabrication, because the gate won't let it. No voice, because that's the part honestly outside scope.
It's the non-parametric route the thread's own technical reply pointed at, built with the pieces at hand. Not the whole dream, but the durable half of it, and the half that was actually breaking.