Mukti

Mukti turns AI into a Socratic mentor—asking, probing, and guiding—so you think clearly, solve deeply, and build lasting cognitive resilience without outsourcing your mind.

Comment

Inspiration

We realized that standard AI chatbots (like ChatGPT or Claude) have a fundamental flaw: Linearity.

When we try to solve complex problems, our thoughts aren't linear—they are messy, branching, and interconnected. We have assumptions, constraints, and dependencies. Trying to solve these in a single chat window often leads to "circular conversations" where we lose track of the core issue.

We wanted to build a tool that respects the shape of thinking. We were inspired by the Socratic method—teaching by asking, not answering—and wanted to combine that with a spatial interface. Mukti (Liberation) was born to liberate our thoughts from the text box.

What it does

Mukti is a Structured Thinking Environment that transforms chaotic problem statements into actionable intelligence.

  1. Socratic Conversations: Unlike standard chats, Mukti asks you to select a "Cognitive Framework" (e.g., Assumption Busting, Perspective Taking) before you start, ensuring the AI challenges you rather than just agreeing with you.
  2. The Thinking Canvas: This is the core innovation. It visualizes your problem as a living ecosystem:
    • Seed: The Core Problem.
    • Soil: The Context & Constraints (what holds you back).
    • Roots: The Assumptions (what you believe to be true).
  3. Context-Aware Dialogue: You can click any node on the canvas to open a dedicated chat. The AI changes its strategy based on what you click:
    • If you click a Constraint, it asks if it's truly fixed.
    • If you click an Assumption, it challenges its validity using evidence-based questioning.
  4. Insight Generation: When you have a breakthrough in chat, you can "Capture Insight," spawning a new node on the canvas. The map grows as your understanding deepens.

How we built it

We built Mukti as a robust, modern Monorepo using Nx and Bun for speed and efficiency.

  • Frontend: Built with Next.js 15 (App Router) and React 19. We used Tailwind CSS and Shadcn UI for a clean, distraction-free aesthetic.
  • Visualization: We utilized React Flow (@xyflow/react) for the canvas. We wrote custom layout algorithms to organize the Seed, Soil, and Roots into a radial/tree structure automatically.
  • Backend: A NestJS API handles the business logic, managing sessions and dialogue state, backed by MongoDB.
  • The AI Engine: We engineered a "Socratic Controller" that dynamically constructs system prompts. It injects the specific context of the selected node and the overall tree structure into the LLM, ensuring the AI "sees" the map while it talks to you.

Challenges we ran into

  • Visualizing Abstract Concepts: It was difficult to determine the best way to visualize a "problem." We iterated through several layouts before landing on the organic "Seed/Soil/Root" metaphor, which required writing custom auto-layout logic in React Flow to keep nodes organized but flexible.
  • State Synchronization: Keeping the visual graph in sync with the chat was a major hurdle. When a user creates an "Insight Node" from the chat panel, we had to ensure it appeared instantly on the canvas with the correct parent-child relationship without refreshing the page.
  • Context Window Management: To make the AI smart, we had to feed it the right amount of context. Too little, and it forgot the constraints; too much, and it got confused. We had to tune the prompt engineering to prioritize the active node while keeping the global problem in the background.

Accomplishments that we're proud of

  • The "Living" Graph: We are incredibly proud that the canvas isn't just a static output. It's interactive. You can modify it, talk to it, and grow it. It feels like a workspace, not just a dashboard.
  • Contextual AI Personalities: We successfully implemented an AI that shifts its "personality" based on where you click. It feels magical when the AI switches from being an "Empathetic Listener" (on the Problem node) to a "Ruthless Auditor" (on the Assumption node).
  • Design System: We built a polished, dark-mode-first UI that feels professional and ready for deep work.

What we learned

  • The Power of Structure: We learned that simply forcing a user to separate "Constraints" from "Assumptions" solves 50% of the problem before the AI even speaks. The interface itself is a thinking tool.
  • Socratic AI is Hard: It's easy to make an AI that answers questions. It's very hard to make an AI that asks good questions. We learned a lot about prompt engineering to stop the AI from being "helpful" (giving answers) and start being "useful" (provoking thought).

What's next for Mukti

  • Collaborative Thinking: We want to add multiplayer support so teams can swarm a problem canvas together in real-time.
  • Export Options: Generating a "One-Pager" PDF strategy document from the finalized canvas.
  • Local LLM Support: Integrating with local models (via Ollama) for privacy-focused users who want to map sensitive business strategies.

Built With

Share this project:

Updates