SolarPlexus Mobius

SolarPlexus Mobius is a visual evidence workspace where you select the sources, trace answers to exact passages, and see when the evidence is not enough. See the Context. Trust the Evidence.

Comment

Inspiration

SolarPlexus Mobius, initially developed under the working name OpenCanvas AI, began with a simple question:

What would AI-assisted knowledge work look like if users could see and control the exact context behind every answer?

Most AI tools compress sources, retrieved passages, assumptions, and generated conclusions into a linear conversation. This can make it difficult to determine what information the model used, why a claim appeared, or whether the available evidence actually supports it.

I wanted to build a system where knowledge remains visible, spatial, and auditable.

SolarPlexus Mobius turns notes, documents, relationships, and AI-generated work into an expandable visual workspace. Users can select the exact information supplied to AI and inspect the evidence behind the resulting answer.

The project was conceived and development began during OpenAI Build Week.

What it does

SolarPlexus Mobius provides an infinite visual canvas where users can organize and connect:

  • Notes
  • PDF, DOCX, Markdown, and TXT documents
  • Relationships between sources and ideas
  • AI-generated responses
  • Citations
  • Retrieval and execution evidence

Users can upload documents, place them on the canvas, connect them to notes, and select the exact nodes that should become AI context.

When a question is submitted, SolarPlexus Mobius retrieves relevant passages only from the selected documents. The resulting response appears as a connected canvas node.

A response is presented as grounded only when the server validates that at least one citation points to a passage that was actually retrieved from a selected source.

Users can click citations to inspect the precise supporting page, heading, section, or extracted passage.

When the selected sources do not contain enough evidence, SolarPlexus Mobius returns an explicit insufficient-evidence response without misleading citations.

The Trace provenance system preserves:

  • The exact user instruction
  • Selected context nodes
  • Immutable context snapshots
  • Retrieved document chunks
  • Retrieval rankings and scores
  • Inclusion and exclusion decisions
  • Model and retrieval configuration
  • Generated response text
  • Validated citations
  • Source relationships
  • Execution status and timestamps

This makes the AI workflow inspectable instead of reducing it to a final answer with no visible history.

How I built it

SolarPlexus Mobius was built as a full-stack application with Codex serving as an engineering partner throughout development.

The frontend uses:

  • Next.js
  • React
  • React Flow
  • React Query
  • TypeScript
  • Zod

The backend uses:

  • FastAPI
  • Pydantic
  • SQLAlchemy
  • Alembic
  • PostgreSQL
  • pgvector

Document processing uses pypdf and python-docx. The system preserves page numbers, headings, sections, chunk indexes, and character offsets where the source format supports them.

The application integrates the OpenAI Responses and Embeddings APIs behind server-side provider interfaces. OpenAI credentials are never exposed to the browser.

Codex accelerated:

  • Repository inspection and architecture planning
  • Backend and frontend implementation
  • Database models and migrations
  • Document-ingestion safeguards
  • Retrieval and citation validation
  • Trace persistence
  • Automated test construction
  • Failure diagnosis
  • Security review
  • Release preparation
  • Competition documentation

I directed the central product and architecture decisions, including:

  • The spatial canvas interaction model
  • Explicit node selection as the AI context boundary
  • Retrieval restricted to user-selected documents
  • Server-validated citation rules
  • Insufficient-evidence behavior
  • The additive canonical architecture
  • The separation of Trace provenance from ordinary application logs
  • The decision to isolate competition demo data from live credentials

The competition version currently runs as a localhost-only deterministic demonstration. Given the Build Week timeline, I prioritized creating a stable, testable, and reproducible local release candidate over rushing an incomplete public deployment.

The demo uses synthetic data, deterministic mock AI and embedding providers, and no live OpenAI credential. It is visibly labeled as replay/demo output and is not represented as live GPT-5.6 output.

Live mode integrates GPT-5.6 through a configurable server-side OpenAI Responses API provider, while the submitted demonstration uses deterministic providers to ensure reproducibility, prevent credential exposure, and avoid requiring paid API usage from judges.

Challenges I faced

One of the largest challenges was maintaining a clear boundary between source evidence and generated interpretation.

It would have been easier to display model-generated citations directly. Instead, SolarPlexus Mobius validates citation identifiers on the server and accepts only citations connected to passages that were actually retrieved from user-selected sources.

Document ingestion was another major challenge. Uploaded files must be treated as untrusted input. The system validates:

  • File size
  • Extension
  • MIME type
  • File signatures and structure
  • Archive expansion limits
  • Storage paths
  • Extracted-text limits
  • Duplicate-processing conditions

Creating durable provenance was more complex than recording ordinary application logs. Trace evidence requires stable identifiers, immutable snapshots, chronological ordering, structured failures, workspace boundaries, and persistence even when active canvas objects are later changed or deleted.

The release process also required making the project reproducible without exposing credentials, using private data, or requiring paid API calls. This led to an isolated deterministic demo with synthetic evidence, reset commands, integrity checks, smoke testing, and judge-specific setup documentation.

Another challenge was preserving the existing canvas and document workflow while introducing a more structured canonical domain model. Instead of rewriting working functionality, I used an additive compatibility strategy so the new Workspace, Document, Chunk, Note, Execution, Relationship, and Trace foundations could coexist with the earlier implementation.

Accomplishments I am proud of

The current build demonstrates both sides of trustworthy AI behavior:

  1. A grounded response with clickable, server-validated supporting evidence.
  2. An insufficient-evidence response that refuses to fabricate support.

The release candidate also includes:

  • Secure PDF, DOCX, Markdown, and TXT ingestion
  • Selected-source retrieval
  • Clickable exact citations
  • Persisted Trace evidence
  • Immutable execution snapshots
  • Deterministic synthetic demo data
  • Automated frontend and backend tests
  • Integration and security tests
  • Database migration validation
  • Production build validation
  • Clean-clone reproduction
  • GitHub Actions CI
  • Judge setup documentation
  • Security and architecture documentation
  • Repository hygiene and secret-scanning checks

The validated release passed:

  • 24 frontend tests
  • 106 backend tests
  • 20 integration tests
  • 17 security tests
  • Strict TypeScript checks
  • Strict mypy checks
  • ESLint and Ruff linting
  • Prettier and Ruff formatting
  • Production build validation
  • Migration upgrade, downgrade, and re-upgrade checks
  • Deterministic demo integrity checks
  • Demo startup smoke testing
  • Clean-clone reproduction

The project also includes a persisted grounded replay with exact citations and a separate insufficient-evidence execution with no citations.

What I learned

This project reinforced that AI transparency is not only a user-interface problem. It requires architectural support across:

  • Retrieval
  • Persistence
  • Citation validation
  • Model configuration
  • Document identity
  • Source relationships
  • Context selection
  • Execution history

I also learned that provenance should be designed at the beginning of a system. Adding it after responses have already been generated can reconstruct only part of what happened.

Most importantly, grounding is not simply attaching a source title to an answer. A credible grounding system must preserve the relationship between:

  • User-selected context
  • Retrieved passages
  • Retrieval rankings
  • Inclusion decisions
  • Generated claims
  • Validated citations
  • Execution configuration

I also learned the value of deliberately limiting scope. Rather than rushing authentication, public deployment, collaboration, and advanced reasoning into one unstable build, I focused on producing a reliable vertical slice that judges can reproduce locally.

Codex was most effective when I used it as an engineering collaborator rather than treating it as an automatic project generator. The strongest results came from defining architecture, constraints, validation gates, security boundaries, and acceptance criteria before implementation.

What's next for SolarPlexus Mobius

Five major milestones remain.

Milestone 4 — Knowledge and retrieval expansion

Broaden how SolarPlexus Mobius searches, connects, and discovers information across larger workspaces.

Milestone 5 — Complete Trace and provenance experience

Develop a more complete visual interface for inspecting, replaying, and comparing AI executions.

Milestone 6 — Workspace intelligence and research workflows

Support deeper analysis across connected documents, notes, relationships, and evidence.

Milestone 7 — Collaboration, security, and scalability

Add authentication, permissions, team workflows, stronger deployment security, and infrastructure for larger workloads.

Milestone 8 — Public product release

Complete hosted deployment, onboarding, public testing, product refinement, and the foundation for a sustainable commercial platform.

SolarPlexus Mobius is still an early competition release candidate, but it demonstrates the central product thesis:

Users should be able to see and control the context an AI system uses—and verify the evidence behind its output.

Built With

Share this project:

Updates