OmniMind

AI Operating System for Your Digital Life

OmniMind is a full-stack prototype that connects fragmented work context across email, calendars, documents, repositories, notes, and cloud storage into one AI reasoning layer.

Demo Video: https://youtu.be/j8BqVoLLN94

---

Overview

Modern work is scattered across Gmail, GitHub, calendars, documents, notes, and cloud storage. Finding information is no longer the hardest problem. The harder problem is understanding how information across different tools connects.

OmniMind creates a reasoning layer across a user's digital life. It connects commitments, meetings, documents, repository activity, and knowledge graph relationships so users can decide what matters next with evidence behind every recommendation.

The current release is a reproducible OpenAI Build Week prototype. It includes deterministic demo services so judges can evaluate the full product flow without connecting private accounts, while preserving the architecture for live OAuth connectors, OpenAI Responses API orchestration, embeddings, and structured outputs.

Core Features

• AI Reasoning Chat: Ask questions about your day, projects, people, documents, or repositories.
• Context-Aware Recommendations: Prioritizes work based on calendar timing, email commitments, project state, and repository risk.
• Evidence-Backed Answers: Responses include tools used, citations, and follow-up actions.
• Knowledge Graph: Shows relationships between people, projects, repositories, meetings, documents, and actions.
• Action Queue: Converts scattered context into prioritized next steps.
• Daily Brief: Summarizes important work, risks, and recommended focus areas.
• Connector Hub: Tracks provider readiness, scopes, sync status, and connected surfaces.
• Activity Timeline: Makes syncs, automations, drafts, graph expansion, and fallback behavior auditable.
• Automation Workflows: Runs proactive workflows for briefs, conflicts, promised replies, and repository risks.
• Document Intelligence: Uploads, chunks, searches, and answers questions against document context.
• GitHub Intelligence: Summarizes repository health, stale work, PRs, issues, and risks.
• Calendar Intelligence: Detects conflicts, prepares meeting context, and suggests schedules.

Architecture

Frontend

• Next.js
• React
• TypeScript
• TailwindCSS

Backend

• FastAPI
• Python
• Deterministic demo services for reproducible judging
• API contracts designed for tool-based OpenAI Responses API orchestration

Database

• Supabase
• PostgreSQL
• Schema prepared for users, memories, documents, repositories, events, graph edges, embeddings, and audit logs

AI Layer

• OpenAI Responses API
• GPT-5.6/OpenAI reasoning capabilities
• Embeddings
• Structured Outputs
• Tool-style orchestration contract with citations and actions

How Codex And GPT-5.6/OpenAI Reasoning Were Used

Codex During Development

Codex was used throughout the development process as an engineering collaborator. It helped build, debug, test, and polish the repository from an early prototype into a public-ready hackathon submission.

Codex assisted with:

• Designing the monorepo structure for the Next.js frontend, FastAPI backend, shared TypeScript contracts, database schema, and scripts.
• Implementing app surfaces including Chat, Actions, Connectors, Automations, Activity, Documents, GitHub Intelligence, Calendar Intelligence, Email Intelligence, Knowledge Graph, Demo Center, and Submission Handoff.
• Debugging browser-to-backend API routing issues by adding a Next.js proxy for /api and /health.
• Improving demo reliability with deterministic backend services and fallback frontend chat responses.
• Fixing UI issues for the final demo, including landing-page logo alignment, graph spacing, and dashboard navigation from Chat.
• Adding smoke tests that validate core backend routes and confirm chat responses vary across prompts.
• Configuring linting, typechecking, build verification, and release documentation.
• Auditing the repository for generated files, local environment files, and secret exposure before public release.

Codex Feedback Session ID:

019f838d-3c04-71e3-82ee-72f26c04e4cc

GPT-5.6/OpenAI Reasoning During Development

GPT-5.6/OpenAI reasoning was used to shape the product concept, demo narrative, and AI interaction model. The project was designed around the idea that AI should not only retrieve isolated facts, but reason across relationships between tools.

During development, OpenAI reasoning helped define:

• The core product framing: an AI operating layer for digital work.
• The "search versus reasoning" distinction used in the demo.
• The structured chat response format: answer, tools, citations, actions, and follow-up questions.
• The cross-source reasoning flow that connects calendar events, email commitments, documents, GitHub activity, and graph relationships.
• The final Build Week demo script and judge flow.

GPT-5.6/OpenAI Reasoning Inside The Application

Inside the prototype, OmniMind exposes the same reasoning contract that a production OpenAI Responses API implementation would use.

For example, when a user asks:

What should I work on today?

OmniMind returns:

• A prioritized recommendation.
• The tool plan used to reach the answer.
• Citations from calendar, email, documents, GitHub, or memory.
• Follow-up questions such as Why? or Show the graph path.
• Actions such as drafting a reply, opening a source, or scheduling a focus block.

When the user asks:

Why?

OmniMind explains the dependency chain across multiple sources: a fixed calendar event, a waiting email commitment, a project document, a GitHub risk, and a knowledge graph relationship. This is the key product idea: OmniMind helps users make decisions by connecting information across their digital life.

The current implementation uses deterministic demo responses for reliability during judging. The production path is to replace the deterministic chat router with OpenAI Responses API calls that invoke retrieval tools, connector tools, graph expansion, embeddings, and structured output validation.

Folder Structure

apps/
  web/        Next.js app, UI routes, reusable components, Supabase client helpers
  backend/    FastAPI app, API routes, auth, settings, and reasoning/demo services
packages/
  shared/     Shared TypeScript response contracts
database/     Supabase/PostgreSQL schema
docs/         Architecture notes and implementation details
scripts/      Local demo launcher and smoke test runner

Installation

1. Clone The Repository

git clone https://github.com/0xKhushwant/OmniMind.git
cd OmniMind

2. Install Frontend Dependencies

npm install

3. Install Backend Dependencies

cd apps/backend
python -m venv .venv
.venv\Scripts\Activate.ps1
pip install -r requirements.txt
cd ../..

On macOS or Linux:

cd apps/backend
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
cd ../..

Environment Variables

Never commit real .env or .env.local files. Use placeholders only in examples.

Create apps/backend/.env:

OPENAI_API_KEY=your_key_here
SUPABASE_URL=your_supabase_url_here
SUPABASE_SERVICE_ROLE_KEY=your_supabase_service_role_key_here
SUPABASE_JWT_SECRET=your_supabase_jwt_secret_here
GOOGLE_CLIENT_ID=your_google_client_id_here
GOOGLE_CLIENT_SECRET=your_google_client_secret_here
GITHUB_CLIENT_ID=your_github_client_id_here
GITHUB_CLIENT_SECRET=your_github_client_secret_here
OPENAI_EMBEDDING_MODEL=text-embedding-3-small
CORS_ORIGINS=http://localhost:3000,http://127.0.0.1:3000

Create apps/web/.env.local:

NEXT_PUBLIC_SUPABASE_URL=your_supabase_url_here
NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY=your_supabase_publishable_key_here
NEXT_PUBLIC_API_URL=
NEXT_PUBLIC_DEMO_AUTH=true
BACKEND_URL=http://127.0.0.1:3001

Backend Variables

Variable	Description
OPENAI_API_KEY	OpenAI API key used for embeddings and future Responses API orchestration
SUPABASE_URL	Supabase project URL
SUPABASE_SERVICE_ROLE_KEY	Supabase service role key for server-side operations
SUPABASE_JWT_SECRET	Supabase JWT secret for token verification
GOOGLE_CLIENT_ID	Google OAuth client ID
GOOGLE_CLIENT_SECRET	Google OAuth client secret
GITHUB_CLIENT_ID	GitHub OAuth client ID
GITHUB_CLIENT_SECRET	GitHub OAuth client secret
OPENAI_EMBEDDING_MODEL	Embedding model name, defaults to text-embedding-3-small
CORS_ORIGINS	Comma-separated allowed frontend origins

Frontend Variables

Variable	Description
NEXT_PUBLIC_SUPABASE_URL	Supabase project URL exposed to the browser
NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY	Supabase publishable key exposed to the browser
NEXT_PUBLIC_API_URL	Optional browser API base URL; leave empty when using the local Next.js proxy
NEXT_PUBLIC_DEMO_AUTH	Enables the reproducible prototype workspace when set to true
BACKEND_URL	Server-side backend URL used by Next.js rewrites

Running The Project

Recommended Demo Command

npm.cmd install
npm.cmd run demo

The launcher starts both the frontend and backend.

• Frontend: http://localhost:3000
• Backend: http://127.0.0.1:3001

If a port is busy, the launcher chooses the next available port and prints the exact URL.

Run Backend Manually

cd apps/backend
python -m venv .venv
.venv\Scripts\Activate.ps1
pip install -r requirements.txt
python -m uvicorn app.main:app --reload --port 3001

Health check:

curl http://127.0.0.1:3001/health

Run Frontend Manually

npm.cmd run dev --workspace @omnimind/web

Open:

http://localhost:3000

Verification

Run the smoke test:

npm.cmd run smoke

The smoke test validates backend health, submission status, demo readiness, actions, activity, connectors, automations, graph, email, calendar, GitHub, documents, and chat response variation.

Run frontend checks:

npm.cmd run lint --workspace @omnimind/web
npm.cmd run typecheck --workspace @omnimind/web
npm.cmd run build --workspace @omnimind/web

Demo

Demo Video:

https://youtu.be/j8BqVoLLN94

Recommended review flow:

1. Open the landing page.
2. Enter the secure workspace.
3. Open Chat and ask What should I work on today?
4. Ask Why? to show cross-source reasoning.
5. Ask Draft the email reply in my tone.
6. Review Actions, Connectors, Automations, Activity, and Submission.

OpenAI Build Week

OmniMind was built for OpenAI Build Week using:

• Codex
• GPT-5.6/OpenAI reasoning capabilities

The goal was to demonstrate how AI can move beyond isolated search and become a reasoning layer for daily work. Codex supported the engineering process, while GPT-5.6/OpenAI reasoning shaped the product interaction model and the app's future production architecture.

Codex Feedback Session ID:

019f838d-3c04-71e3-82ee-72f26c04e4cc

Future Improvements

• Replace deterministic demo routing with live OpenAI Responses API orchestration.
• Add production OAuth sync for Gmail, Google Calendar, Google Drive, GitHub, and cloud storage.
• Store embeddings in Supabase pgvector for scalable semantic search.
• Add organization workspaces, role-based access control, and audit exports.
• Expand automation workflows with scheduling, approvals, and notification delivery.
• Add richer graph exploration, path explanations, and confidence scoring.
• Deploy the frontend on Vercel and the backend on Railway, Fly.io, or a similar platform.

Security

This repository is prepared for public release. Generated folders, local environment files, and secret files are ignored by default.

Do not commit:

• .env
• .env.local
• API keys
• OAuth secrets
• Supabase service role keys
• Generated dependency or build folders

See SECURITY.md for responsible disclosure details.

License

MIT. See LICENSE.