Skip to content
BranchesTags

Repository files navigation

EIDOS AI

"Google Maps for Life Decisions"

EIDOS AI is an AI Decision Companion — an artificial intelligence system that helps people make decisions by listening to their problems, visualizing them as decision graphs, and navigating through choices with trade-off analysis.

Core Problem

Humans make poor decisions due to 3 cognitive limitations:

  • Cannot see the full picture — Too many factors, cross-interactions, impossible to visualize
  • Cannot remember thinking models — Decision frameworks (regret minimization, second-order thinking, game theory...) exist but humans forget to apply them
  • Cannot simulate the future — Decisions require predicting the future, but the human brain struggles with uncertainty, unknown variables, and second-order effects

The fundamental question this product solves: "What should I do?"

Solution: Decision Intelligence Interface

Core Flow

User describes problem
      ↓
AI extracts decision factors
      ↓
Applies appropriate thinking models
      ↓
Generates decision graph / maze
      ↓
Simulates outcomes over timeline
      ↓
Visualizes trade-offs
      ↓
User explores paths → makes decision

AI acts as navigator, not decider:

  • Suggests feasible paths
  • Analyzes trade-offs of each choice
  • Reminds users of their personal constraints
  • Automatically selects and applies appropriate thinking models

System Architecture

Monorepo Structure

eidos-ai/
├── eidos-web/          Next.js 15 frontend (Vercel)
│   ├── app/            App Router pages
│   ├── components/     React components (graph, chat, trade-off)
│   ├── stores/         Zustand state management
│   └── lib/            API client, hooks, utilities
│
├── eidos-api/          NestJS backend (Railway/Fly.io)
│   ├── src/modules/
│   │   ├── auth/       Passport JWT + Google OAuth
│   │   ├── ai/         ← CORE PIPELINE
│   │   │   ├── problem-parser.service.ts
│   │   │   ├── factor-extractor.service.ts
│   │   │   ├── graph-generator.service.ts
│   │   │   └── thinking-model.service.ts
│   │   ├── decision/   Decision CRUD & history
│   │   ├── graph/      Graph operations & layout
│   │   └── chat/       Conversation management
│   └── prisma/         Database schema & migrations
│
└── eidos-shared/       Shared TypeScript types & Zod schemas
    ├── types/          Decision, Graph, User types
    ├── schemas/        Zod validation schemas
    └── constants/      Node types, edge types, thinking models

Packages Overview

@eidos-ai/web (Frontend)

Next.js 15 application serving the user interface. Handles all client-side interactions including decision exploration, graph visualization, and AI conversations.

Key Features:

  • Interactive decision graph canvas (React Flow)
  • Real-time AI streaming responses (SSE)
  • Conversational clarifying questions UI
  • Trade-off visualization (radar charts, comparison tables)
  • Decision history & management
  • Authentication (JWT + Google OAuth)

Tech Stack: Next.js 15, React 19, Zustand, Tailwind CSS v4, TypeScript

Deploy: Vercel

@eidos-ai/api (Backend)

NestJS application providing the core AI pipeline and business logic. Handles authentication, decision processing, graph generation, and data persistence.

Key Modules:

  • ai/ — Core AI Pipeline (problem parser, factor extractor, graph generator, thinking model matcher, LLM provider)
  • auth/ — JWT authentication + Google OAuth (Passport)
  • decision/ — Decision CRUD operations, history, sharing
  • graph/ — Graph data management, layout algorithms
  • chat/ — Conversation management for clarifying questions
  • user/ — User profiles & personal constraints
  • prisma/ — Database client & migrations

Tech Stack: NestJS, Prisma ORM, PostgreSQL (Neon), Passport, BullMQ, OpenAI API, Claude API

Deploy: Railway / Fly.io

@eidos-ai/shared (Shared Library)

TypeScript package containing shared types, Zod schemas, and constants used by both frontend and backend. Ensures type safety and consistent validation across the monorepo.

Exports:

  • Types — Decision, Graph, Node, Edge, User, AuthTokens, JwtPayload
  • Schemas — Zod schemas for AI output validation (DecisionGraphSchema, FactorSchema, ClarifyingQuestionsSchema)
  • Constants — NodeType, EdgeType, thinking models list

Tech Stack: TypeScript, Zod

Usage: Imported by both @eidos-ai/web and @eidos-ai/api for type-safe data exchange

Tech Stack Summary

Frontend: Next.js 15, React 19, React Flow, Zustand, Tailwind CSS v4, shadcn/ui, SSE

Backend: NestJS, Prisma ORM, PostgreSQL (Neon), Passport, BullMQ, OpenAI GPT-4o, Claude

Shared: pnpm workspace, TypeScript strict mode, Zod validation

Getting Started

Prerequisites

  • Node.js 20+
  • pnpm 10+
  • PostgreSQL database

Installation

# Clone repository
git clone <repo-url>
cd eidos-ai

# Install dependencies for each package
cd eidos-api && pnpm install
cd ../eidos-web && pnpm install
cd ../eidos-shared && pnpm install

Development

# Start backend (localhost:3001)
cd eidos-api
pnpm dev

# Start frontend (localhost:3000)
cd eidos-web
pnpm dev

Environment Variables

Copy .env.example to .env in each package and configure:

eidos-api/.env:

DATABASE_URL="postgresql://..."
JWT_SECRET="your-secret"
OPENAI_API_KEY="sk-..."
GOOGLE_CLIENT_ID="..."
GOOGLE_CLIENT_SECRET="..."

eidos-web/.env:

NEXT_PUBLIC_API_URL="http://localhost:3001"

Decision Graph Structure

Node Types

  • Factors — Decision-influencing elements (salary, risk, learning, identity, stress)
  • Constraints — Personal limits set by user (income ≥ $3k, work < 50h/week)
  • Options — Available choices (combinations of factors)
  • Outcomes — Path consequences (wealth potential, stress level, failure risk)
  • Time Horizons — Temporal dimension (Year 1, Year 3, Year 5, Year 10)

Edge Types

  • INFLUENCES — Factor → Option
  • LEADS_TO — Option → Outcome
  • CONSTRAINS — Constraint → Option (blocks/allows)
  • EVOLVES_TO — Outcome → Time-based outcome
  • CONFLICTS — Factor ↔ Factor
  • SUPPORTS — Factor → Factor

AI Pipeline (5 Stages)

  1. Problem Parser — Parse raw user text → structured problem statement
  2. Clarifying Questions — Generate 3-5 targeted questions (risk tolerance, timeline, constraints)
  3. Factor Extractor — Extract 5-12 factors with importance ratings & conflict detection
  4. Graph Generator — Generate complete decision graph (nodes + edges + layout)
  5. Thinking Model Matcher — Match & apply thinking models (Regret Minimization, Second-Order Thinking, Game Theory...)

All outputs validated using Zod schemas from @eidos-ai/shared.

Roadmap

Version Features
v1 (MVP) AI Decision Graph — core visualization, factor extraction, trade-off analysis
v2 Decision Memory — prediction vs outcome tracking, personal insights dashboard
v3 Future Simulation — timeline-based outcome modeling, Monte Carlo scenarios
v4 Life Map — full spatial navigation across life domains, Decision Network (social), API platform

Current Phase: v1 MVP — validating core UX

Documentation

  • AGENTS.md — Development guide for AI agents/contributors

Contributing

See AGENTS.md for code style, naming conventions, and development workflow.

License

Proprietary — All rights reserved

Vision

Thinking Software — not an AI assistant that answers questions, but a system that helps humans navigate decisions.

If built correctly, EIDOS AI is not just an app but a new layer of software between AI and humans.

A hybrid of:

  • Notion → workspace for thinking
  • Google Maps → navigation in decision space
  • The Sims → life simulation

Potential to become the AI app opened most frequently each day, because humans are constantly making decisions.

About

No description, website, or topics provided.

Resources

Readme
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors