We built it like every other AI system
When we started building Aaradhya on CloYou, we had a simple assumption: users would treat it like any other AI system. They would come in, ask questions, expect answers, and move on. That’s how most tools are used today, and honestly, that’s what we optimized for.
We focused on improving response quality, making conversations feel natural, and ensuring the system could handle a wide range of queries. On paper, everything made sense. It followed the same proven pattern:
input → response → done
But the moment real users started interacting with it, that assumption started breaking.
The first sign something was off
The early interactions didn’t look like what we expected.
Instead of structured queries or task-driven prompts, users were typing things that felt… different. Less like commands, more like expressions.
They weren’t asking:
- “Explain this concept”
- “Give me steps for this problem”
- “How does this work?”
They were saying things like:
- “Let’s create something together”
- “Imagine this moment”
- “Let’s try this scene”
At first, it looked random. But the more we observed, the clearer it became—this wasn’t noise. This was a pattern.
They weren’t using it like a tool
This is where things got interesting.
Users weren’t treating Aaradhya like a typical AI tool. They weren’t trying to extract maximum efficiency from it. Instead, they were spending time with it.
The interaction felt closer to:
- exploring ideas
- building something gradually
- continuing a flow rather than finishing a task
That shift might sound small, but from a system design perspective, it changes everything. Because now you’re not designing for “task completion,” you’re designing for interaction continuity.
The features quietly changed user behavior
We didn’t explicitly guide users toward this behavior. It emerged naturally from how the system worked.
🔹 Image upload changed ownership
When users were able to upload their own image, something subtle but powerful happened. They were no longer just observing the output—they became part of it.
Instead of:
“AI generated this”
It became:
“I’m inside this moment”
That single shift moved the experience from generic to personal. It gave users a reason to engage beyond curiosity.
🔹 Consistency made it believable
Most generative systems struggle with consistency. You might get a great output once, but over multiple interactions, things start to drift.
- faces change
- styles shift
- nothing feels connected
We focused heavily on maintaining identity—both for the user and for Aaradhya. The goal wasn’t just visual accuracy, but continuity across moments.
That continuity is what made users stay. Because now it didn’t feel like separate outputs—it felt like something evolving.
🔹 Memory changed how people returned
We also experimented with memory, but in a very controlled way.
Instead of automatically saving everything (which quickly becomes clutter), we let users decide what mattered. They could create a moment and choose whether to keep it.
This had an unexpected effect.
Users didn’t just come back to start new interactions. They came back to continue existing ones.
That’s a very different behavior loop.
The biggest surprise wasn’t technical
We expected users to:
- refine prompts
- optimize inputs
- treat the system like a tool
They didn’t.
What they actually did was much simpler:
They explored. They imagined. They created.
Not efficiently. Not systematically. But naturally.
And that tells you something important: when given the option, people don’t always want better tools. Sometimes, they want better experiences.
This changed how we see AI systems
Up until this point, we were thinking in terms of improving outputs—better answers, faster responses, more accurate results.
But this experiment showed something else.
The value wasn’t just in the output. It was in the interaction itself.
Aaradhya wasn’t evolving into:
- a better chatbot
- a smarter assistant
It was becoming something closer to an interaction space—where things don’t just end, they carry forward.
Not questions. Not answers. Something in between
Traditional AI systems are designed around completion. You ask, it answers, and the loop ends.
But what we started seeing here was a different loop:
- interaction
- continuation
- creation
Instead of closing the loop, it keeps going.
And that’s what makes it feel different.
Where Aaradhya fits in
Aaradhya is not just a conversational layer added on top of an AI model. It’s the result of combining multiple ideas:
- interaction instead of instruction
- identity instead of randomness
- continuity instead of reset
- creation instead of just output
Individually, these don’t sound groundbreaking. But together, they change how the system is used.
What this might mean going forward
If users naturally move toward interaction-based behavior, then maybe our current design assumptions are incomplete.
We’ve been optimizing AI for:
- speed
- accuracy
- efficiency
But maybe we also need to think about:
- continuity
- experience
- engagement over time
Because that’s what users seem to gravitate toward when given the choice.
Final thought
We thought users would ask questions.
They didn’t.
They stayed longer. They explored more. They created moments.
And that shift might be more important than any feature we built.
🚀 Try it yourself
If you want to experience this firsthand:
Try Aaradhya. Don’t go in with a task.
Just start with something simple like:
“Let’s create something together.”
And see where it goes.
Top comments (0)