thesision

Thesision turns engineering questions into transparent, evidence-backed reasoning graphs—showing trade-offs,conflicts, confidence, and what could change a decision.

Comment

Inspiration

Software engineers often need to choose between architectures, platforms, or infrastructure options while the evidence is incomplete and trade-offs conflict. A confident AI answer does not show what supports the recommendation, what remains uncertain, or what would change the decision.

Thesision is built for engineers who need to inspect a technical decision before acting on it.

What it does

Thesision turns one engineering question into a visible, evidence-backed decision record. It generates competing hypotheses, retrieves grounded evidence, compares engineering perspectives, identifies conflicts, produces a Judge synthesis, and creates a conditional conclusion.

Instead of asking users to trust a chat response, Thesision lets them inspect clickable evidence sources, conflicts, confidence signals, caveats, and the conditions that could change a recommendation.

Users can replay the reasoning graph, export concise Markdown reports, export or import canonical JSON sessions, and continue a previous reasoning session without changing the original record.

How we built it

We built Thesision with FastAPI, SQLite, and a strict TypeScript frontend. The frontend renders a deterministic constellation-based reasoning graph so replayed, imported, and continued sessions remain visually stable.

GPT-5.6 Luna is the structured reasoning engine. It generates hypotheses, evaluates engineering perspectives, synthesizes the Judge result, creates conditional conclusions, and composes reports from canonical session data. We use structured artifacts and validation between stages rather than relying on a single answer prompt.

Perplexity Sonar retrieves grounded web evidence through AI/ML API web search. Evidence URLs are accepted only when returned by the search provider.

How we used Codex

Codex was an implementation collaborator throughout the project. It accelerated:

  • the orchestrator-first backend structure and regression tests;
  • TypeScript migration and modular frontend refactoring;
  • the constellation graph layout, animation, sidebar, popups, replay, and continuation interactions;
  • RFC-driven design and architecture documentation;
  • Render deployment configuration and health checks; and
  • Judge/Conflict output validation, source-grounding safeguards, Markdown-report improvements, debugging, and final submission preparation.

Human decisions remained responsible for product direction, reasoning architecture, acceptance criteria, and final implementation choices.

Challenges we ran into

The hardest problem was preventing transparent reasoning from becoming fake transparency. A model can return valid JSON while omitting a meaningful Judge synthesis, or cite a plausible but unrelated source.

We addressed this by validating Judge output, requesting one structured repair for incomplete results, and failing explicitly rather than showing empty or fabricated Judge and Conflict nodes. We also constrain evidence links to provider-returned search citations.

Accomplishments that we're proud of

  • Built a working reasoning workflow rather than a chat wrapper.
  • Made uncertainty visible through conflict nodes, confidence signals, caveats, and decision-change conditions.
  • Created an interactive graph with replay, evidence satellites, popups, and stable layouts.
  • Preserved portability through JSON export/import and session continuation.
  • Grounded evidence URLs instead of trusting model-recalled citations.
  • Deployed a public demo on Render.

For judges: test it in under a minute

Live demo: https://thesision.onrender.com

No login is required. A free Render instance can take about a minute to wake up.

  1. Enter: “Should an early-stage AI startup use Docker Compose, a managed container platform, or Kubernetes for production deployment before reaching product-market fit?”
  2. Select Start Reasoning.
  3. Inspect the Evidence, Conflict, and Judge nodes; open an evidence-source link.
  4. Export the completed session as Markdown or JSON.
  5. Optionally import the JSON and select Continue Reasoning to investigate the highest-priority recorded gap while preserving the original record.

Repository and local setup, test, and deployment instructions are available at https://github.com/einzeinn/thesision.

What we learned

Transparency is not just exposing more text. It requires clear contracts between reasoning stages, honest handling of missing information, and a visual structure that helps people understand a decision quickly.

We also learned that low confidence is not necessarily a product failure. When evidence is incomplete or conflicts remain, showing that uncertainty is more useful than producing an overconfident answer.

What's next for Thesision

Next, we want to improve evidence-source diversity, add more structured evidence-to-hypothesis links, strengthen confidence calibration, and support richer engineering domains. We also plan to explore persistent storage and collaborative decision review while keeping the human engineer as the final decision-maker.

Built With

Share this project:

Updates

posted an update —

A small development update: we improved how Thesision handles multi-round reasoning. Previously, later rounds could

still feel too close to the original question, even after the graph had surfaced new evidence, trade-offs, or unresolved conflicts. We changed that so each new round now focuses on the most important recorded gap from the previous one—for example, an unresolved conflict, weak evidence, a perspective trade-off, or a condition raised by the Judge. We also updated the report so it reflects unique evidence collected across all completed rounds, rather than only the latest round.

We made this change because transparent reasoning should become more focused as more information is collected, not simply produce another variation of the same answer. We are sharing it here instead of revising the current submission materials because the July 21 deadline is close, and we want to preserve the submitted demo as an accurate snapshot while documenting this final stability and reasoning-quality improvement clearly.

Log in or sign up for Devpost to join the conversation.