Atlas Jiwa — Human Reflection

A scenario-based human reflection platform that helps people explore everyday moments, choices, and consequences without diagnosis, scores, or mental-health labels.

Comment

Inspiration

We started with a simple question:

Why does exploring mental health have to feel like being tested for a mental illness?

Many people are curious about their own behavior, habits, decisions, relationships, and emotions. But the moment something is called a mental health screening, it can feel clinical, judgmental, or intimidating.

We also questioned the idea of building yet another mental-health chatbot.

With ChatGPT and many other AI assistants already available, simply creating another chatbot where people "talk about their feelings" did not feel like enough.

So we took a different direction.

Instead of asking:

"What's wrong with you?"

Atlas Jiwa asks:

"What happened, and what can you learn from it?"

We wanted to explore the small moments that happen every day:

not replying to a message, avoiding someone, postponing something important, finding it difficult to stop doing something, making an impulsive decision, comparing ourselves with others, saying yes when we actually wanted to say no, and many other ordinary human experiences.

The goal is not to label people.

The goal is to give people a comfortable place to pause, explore, and understand themselves a little better.

What it does

Atlas Jiwa — Human Reflection is a scenario-based mental health education and self-reflection platform.

Instead of one large questionnaire, the experience is built around individual everyday scenarios.

A user chooses a situation that feels familiar and explores it through a sequence of interactive cards.

The scenario can branch depending on the user's choices.

For example:

Everyday situation ↓ Context ↓ Choice ↓ Exploration ↓ Possible consequences ↓ Reflection ↓ Personal narrative

Different scenarios can use different reasoning approaches because every human situation is different.

Importantly, Atlas Jiwa does not present:

diagnostic labels, psychological scores, percentages, risk rankings, or personality classifications.

The system uses its internal reasoning only to create a more relevant reflection experience.

The user sees the human explanation, not the internal scoring logic.

Our current hackathon scope contains 25 reflection scenarios, designed to demonstrate the breadth of the concept without overwhelming the people evaluating or using it.

How we built it

How we built it

Atlas Jiwa is intentionally built with a relatively simple technical architecture.

The core experience uses a universal HTML shell that provides the consistent interface, navigation, responsive behavior, bilingual support, and light/dark themes.

Individual scenarios are implemented as self-contained JavaScript modules.

Conceptually:

                     ATLAS JIWA
                          │
                          ▼
                ┌───────────────────┐
                │   UNIVERSAL SHELL │
                │     index.html    │
                └─────────┬─────────┘
                          │
          ┌───────────────┼───────────────┐
          │               │               │
          ▼               ▼               ▼
     SCENARIO 001    SCENARIO 002    SCENARIO 003
          │               │               │
          ▼               ▼               ▼
    INTELLIGENCE      INTELLIGENCE      INTELLIGENCE
          │               │               │
          ▼               ▼               ▼
     REFLECTION        REFLECTION        REFLECTION

Each scenario can contain its own:

questions, choices, branching, contextual reasoning, consequence exploration, reflection, narrative generation, and safety boundaries.

This means we don't need one enormous psychological reasoning engine trying to understand every possible human situation.

Instead:

Small engine. Specific purpose. Human-centered outcome.

The interface remains consistent so users don't have to learn a new interaction pattern for every scenario, while the intelligence behind each scenario can remain unique.

The project is also designed around a privacy-conscious principle: the experience should not require users to provide a personal identity simply to explore a reflection scenario.

Challenges we ran into

The biggest challenge was not writing the code.

It was deciding what the software should actually do.

It is surprisingly easy to turn a mental-health product into a collection of scores, labels, and categories.

We deliberately moved away from that approach.

Another challenge was language.

Some early scenario content sounded too much like psychological terminology. A person who has never studied psychology should not need a psychology degree to understand a reflection exercise.

So we repeatedly simplified the language.

Instead of:

"Does this behavior indicate an avoidance mechanism?"

we prefer something closer to:

"What usually makes you want to step away from the situation?"

We also had to solve a technical challenge:

How can dozens of different scenario engines live inside one consistent product without turning the application into one huge piece of code?

The solution was the universal shell + self-contained scenario architecture.

Finally, we had to balance ambition with usability.

We could have created 50, 100, or even more scenarios simply to demonstrate scale.

But more content does not automatically create a better product.

For the hackathon, we chose 25 carefully designed scenarios.

That decision itself follows one of our core principles:

Human-centered outcome over feature count.

Accomplishments that we're proud of

We are proud that Atlas Jiwa became something different from the generic mental-health chatbot concept we initially considered.

We built a system where the same interface can host many different reflection experiences while allowing each scenario to have its own reasoning approach.

We are particularly proud of three things.

  1. We removed the pressure of being "diagnosed"

A person can explore a scenario simply because they are curious about themselves.

They don't have to think:

"Maybe something is wrong with me."

They can simply think:

"Hmm, I'm curious why I do this."

  1. We made the interaction itself part of the reflection

The user doesn't simply receive an answer.

They make choices.

Those choices determine where the exploration goes next.

The experience therefore becomes a small journey rather than a static questionnaire.

  1. We kept the technology simple enough to iterate

We intentionally did not build a giant, complicated architecture just to make the project look technically impressive.

Instead, we focused on small, purpose-built engines that solve specific human interaction problems.

For us, sophisticated software is not necessarily software with the most complicated code.

It is software that produces a better outcome for the person using it.

What we learned

We learned that the hardest part of building AI-assisted software is not generating code.

It is deciding what should be generated in the first place.

AI can help us create code, explore ideas, generate scenario logic, and iterate much faster.

But AI does not automatically know whether an experience is comfortable, meaningful, confusing, judgmental, or unnecessary for a particular human being.

That requires product thinking, testing, observation, and continuous quality control.

We also learned that mental-health technology requires a different mindset.

Adding more intelligence does not necessarily make the experience better.

Sometimes the best improvement is simply changing one sentence so that a person feels less judged.

That led us to a principle we now use throughout Atlas Jiwa:

Human-centered outcome.

We don't ask only:

"Can the engine do this?"

We ask:

"What does this change do for the person using it?"

What's next for Atlas Jiwa — Human Reflection

The 25 scenarios created for this hackathon are only the beginning.

Our next goal is to continue improving the quality and diversity of the reflection experiences rather than simply increasing the number of scenarios.

Future versions could explore:

more everyday situations, richer branching, more personalized reflection, improved accessibility, stronger multilingual experiences, deeper educational content, offline or privacy-first processing, and better ways to help users recognize patterns across their own reflections.

But we want to preserve the central idea.

Atlas Jiwa should never become a machine that tells people:

"This is what is wrong with you."

We want it to remain a space where people can ask themselves:

"Why do I do this?"

"What happened here?"

"What else could I see from this situation?"

And perhaps, after a few minutes:

"I understand myself a little better now."

That is the outcome we are building for.

Atlas Jiwa — Human Reflection

Understand the small moments before they become bigger patterns.

Built With

Share this project:

Updates