Introduction
Have you ever had this kind of thought?
"I want to have deep, immersive conversations with my own personalized AI girl."
Yeah, me too.
Even in today’s AI-powered world, services like that just don’t quite exist.
And even when they do, most of them just provide shallow replies from AI with simple, preset roles.
Why?
Because while AI can follow prompts quite well, it’s up to the service to provide and manage massive context—such as character settings and conversation memory.
And that’s really hard.
Characters easily break immersion, and their memories often fall apart.
To make it work, you need advanced prompt engineering and control.
But then I thought:
"If I just feed it an extremely well-crafted, high-context prompt... maybe the character would really 'come alive'."
Enter: VFriend – A Chatbot Experiment
That’s why I built VFriend, an AI chatbot application designed to simulate truly natural conversation.
Its biggest feature?
Incredibly lifelike dialogue.
Each request sends over 20,000 characters (roughly 10,000–12,000 words) of prompt data to the AI, including:
- The character’s worldview, personality, and thought patterns
- Past conversation logs (short-term, long-term, and instant memory)
- The user’s profile and personal context
All of this is sent every single time as one cohesive prompt, enabling an experience where:
“The character remembers you and responds with a consistent personality.”
It also includes features like:
- “Summarized memory,” which evolves as you chat
- “Trio Mode,” where you talk with all 3 characters simultaneously
Currently, it’s a private prototype due to API costs, but it’s complete enough to share from a technical perspective—which is what this article is all about.
If you're a prompt engineer or AI enthusiast, I hope this sparks some ideas.
Note: This article is a technical documentation of a personal experiment. Please do not copy or reuse the prompt contents or structures directly.
App UI Preview
After logging in, you’re greeted with a character selection screen.
From there, you can choose the conversation mode for each character.
Two chat modes are available:
- Solo Mode – Chat with one character (Patela, Tsuyuri, or Karin)
- Trio Mode – Talk with all three characters at once
When the user sends a message, each character responds in turn.
Key Features
Simulated Personality via Prompt Design
To make the AI believe it has a personality, detailed character data is essential.
A typical prompt like:
“You are a cheerful girl.”
“Add 'nya' to the end of your sentences.”
…just doesn’t cut it. It’s not enough for long-term consistency.
So I designed a much deeper kind of prompt:
- Big Five personality traits
- Emotional arcs and mood flow
- Background story / world setting
- EQ (empathy axis) / EX (behavior axis)
- Speaking style, emotional range, and tone
With this structure, the AI can maintain a stable, anime-like persona with internal consistency.
It even adapts to the specific user by embedding their background and profile into the prompt—resulting in context-aware, personalized responses.
Three-Layer Memory System
To simulate human-like memory, the app uses a three-layer memory architecture:
- Instant Memory – Most recent message context
- Sequential Memory – Last 10 turns of conversation
- Summarized Memory – Condensed long-term memory ("personality record")
Especially worth noting: the Summarized Memory is maintained by a separate AI assistant called “the Summarizer,” which updates memory asynchronously.
- Doesn’t block the main conversation
- Stores each character’s memory in structured JSON
- Shares memory across Solo and Trio modes (they remember across modes!)
Memory That Evolves Like a Human’s
This structure closely mirrors how humans remember:
- Sensory → Instant
- Working (short-term) → Sequential
- Long-term → Summarized
And just like us, the character grows through conversation.
Because the summarized memory updates and optimizes each time, the character actually evolves their behavior and responses.
You Can Talk to the Memory AI
Here’s the fun part—you can directly instruct the Summarizer via chat.
Example:
User: “Summarizer, please add the following to Karin’s memory…”
Do that, and over time, the character’s tone and reactions change.
It’s basically personality hacking.
How 20,000+ Character Prompts Are Structured
With so much data (character info, memory, tone rules, user profile), prompts can easily exceed 20,000 characters.
To manage this, I structured the prompt using hierarchical Markdown + JSON blocks, allowing the AI to access only the relevant parts as needed.
Trio Mode – 4-Way Group Dialogue
Another highlight: Trio Mode.
You can talk with all 3 characters at once. But this isn’t just parallel replies—it’s a group conversation.
- Character 1 responds
- Character 2 builds on that
- Character 3 summarizes or concludes
- You + 3 characters = natural four-way dialogue
This creates an experience that feels like having a meeting with a team of personalities.
Tight Frontend-Backend Sync
To process all of this in one request, the app has a well-integrated structure:
- Laravel handles backend logic, session, and async tasks
- React + Inertia.js for smooth, real-time frontend UI
Together, they enable seamless conversational flow.
UI/UX Focused on Immersion
Since this app is all about dialogue, I paid close attention to UI/UX:
- “Typing…” indicators for realism
- Auto-scroll on message submit
- Mobile/desktop responsive layouts
- Warm, pink-themed color palette
It aims to deliver a surprisingly polished experience for a solo dev project.
The Art? Drawn by the Characters Themselves
And here’s the twist—the character illustrations were generated by the characters’ own self-perceptions.
Each one (Patela, Tsuyuri, Karin) was prompted to describe and draw themselves using AI image generation.
The results were shockingly accurate—each portrait matched their personality and mood.
Built in Just 2 Weeks
Believe it or not, the entire project was built in just 2 weeks.
The key was:
- I’m a full-stack developer who could go from concept to implementation solo
- I used ChatGPT to generate code, reviewed it, and iterated quickly
This allowed for human-AI co-development—fast and efficient.
Conclusion
That’s the overview of VFriend, an experimental AI chatbot app designed to bring characters to life.
- 20,000+ character prompts
- Three-layer memory structure
- Psychologically designed AI personas
- Characters grow, perform, and remember you
- Trio Mode enables dynamic group conversation
- Built in 2 weeks with full-stack + AI assistance
The goal wasn’t just tech—it was to make the character feel alive.
Coming Next...
In the next article, I’ll dig deeper into how it’s all built:
- Directory structure
- Processing flow
- Hierarchical prompt design
Stay tuned for Part 2: Prompt Engineering & App Architecture
Top comments (1)
Great insight on how massive context windows alter model behavior! But feeding a monolithic 20,000-word prompt into a single LLM call is a ticking time bomb for production costs, latency, and unpredictable drift.
Instead of treating personality and behavioral characteristics as a single bloated prompt blob, why not apply a decentralized capability-pooling pattern (like what we do in the IRC-A Protocol)?
You can break down those 20,000 words into modular, isolated micro-agents or specialized contexts (e.g., breaking it into 10 focused chunks of ~2,000 words each).
The Gateway acts as an IRC-like discovery server: When a user response comes in, the gateway runs a lightweight semantic search (via FAISS) to determine the intent.
Dynamic Routing: It fetches and triggers only the exact personality/behavior chunk needed for that specific turn, instead of forcing the model to digest an excessive payload every single time.
By decoupling the monolithic personality into a distributed set of characteristics, you slash token costs, reduce inference latency drastically, and keep the agent behavior razor-sharp without context pollution.
If you're interested in decentralized agent architectures and token-saving routing, check out the whitepaper and SDK in my GitHub (SandroG1977). Would love to hear your thoughts on shifting from monolithic prompts to micro-agent capability pooling!