Orchide Ai

A dual-LLM cognitive architecture that completely isolates tactical reasoning from linguistic expression to enforce absolute truth provenance in complex research.

Comment

The Inspiration: Dismantling Epistemic Decay

The tech industry currently treats Large Language Models as decentralized encyclopedias. We realized this is a fundamental flaw. LLMs are probabilistic prediction engines, not static data warehouses. When you force a single AI model to simultaneously retrieve factual market data, formulate research strategies, and synthesize multi-lingual communication, it creates a cognitive bottleneck. The inevitable result? Systemic hallucination, disguised by highly confident, beautifully formatted text.

We wanted to build a verifiable truth engine a civilization-scale cognitive architecture. The inspiration for Orchid Intelligence was born from a desire to move beyond incremental "wrapper" apps and construct a system grounded in first-principles reasoning. We didn't want to optimize how people search; we wanted to fundamentally restructure how humanity interacts with and verifies complex financial information.

What It Does

Orchid is an AI-native, multilingual research platform built on a strict Dual-LLM Orchestration pattern. It separates the cognitive labor of research into two distinct layers:

  • The Planner (DeepSeek R1 via OpenRouter): Operates entirely in the background to handle intent understanding, query decomposition, and agent routing.
  • The Executor (Sarvam AI): Consumes the verified context to handle multilingual translations and neural voice synthesis.

By enforcing a "tool-first" pipeline, Orchid prevents the fabrication of market data. It pulls real-time signals exclusively from approved structured APIs (GNews, Yahoo Finance, Moneycontrol) and meets users where they are, offering a native voice-agent experience across 7 global languages.

How We Built It

Building this required a highly decoupled, state-driven backend architecture. Collaborating alongside the core technical team. We engineered a full-stack environment using React 19, Vite, and Bun for the frontend, supported by a dynamic vercel.json SPA routing configuration.

For the intelligence layer, we utilized openrouter/auto to act as a meta-orchestrator, routing tasks to DeepSeek R1 for heavy logical planning. The voice layer is driven by Sarvam AI's bulbul:v3 model, seamlessly integrated into a 3D interactive Spline scene for the /voice route.

The Mathematics of Truth Provenance

To achieve institutional-grade reliability, our Synthesizer Agent calculates a dynamic confidence score for every research brief. Rather than relying on the LLM's inherent confidence, we modeled the score C as a function of source reliability R_s, data freshness F_t, and reasoning alignment A_r.

For a given set of n retrieved API signals, the baseline data integrity is calculated using normalized source weights w_i. Because financial data decays rapidly in value, we apply an exponential decay function where \lambda represents the volatility of the specific market sector over time t:

$$C = \left( \sum_{i=1}^{n} w_i R_{s_i} \right) \cdot e^{-\lambda(t - t_0)} \cdot A_r$$

This formal scoring ensures that an output is only flagged as "high confidence" if the underlying structured data is both authoritative and chronologically relevant to the execution timestamp t_0.

Challenges We Faced

  1. Decoupling Cognitive Load: Forcing DeepSeek R1 to only plan and never speak directly to the user required aggressive prompt engineering and output parsing. We had to build custom regex handlers to strip <think> reasoning tags before passing the JSON execution plans downstream.
  2. API Rate Limiting: Handling heavy, concurrent API requests across multiple intelligence providers threatened to break our system. We engineered a custom circuitBreaker.js session-level quota manager. If the daily limit is exhausted, the system elegantly traps the error and routes the user to a localized demo mode rather than crashing the interface.
  3. Voice-State Synchronization: Orchestrating the React state between the user's microphone, the live transcript generator, the AI reasoning delay, and the Sarvam neural TTS playback required highly precise asynchronous event handling.

Accomplishments We're Proud Of

  • Zero Web Scraping: We successfully built a strict Retrieval-Augmented Generation (RAG) loop that relies entirely on structured data APIs, practically eliminating the hallucination surface area.
  • The Voice Orb Architecture: We didn't just bolt a microphone onto a chat UI. We built a completely dedicated /voice route that feels like interacting with a next-generation intelligence, complete with real-time 3D visual feedback.
  • A "Quiet UI": We maintained extreme design minimalism. By sending the heaviest technical agent traces and signal metrics directly to the browser's developer console, we kept the frontend visually calm while remaining highly auditable for power users.

What We Learned

We learned that true innovation in AI isn't about using the largest parameter model available; it is about orchestration. RAG is not just vector search it is the meticulous routing of verifiable data flows. We also learned how to aggressively cache volatile market signals using low-TTL datastores to dramatically reduce redundant model invocations.

What's Next for Orchid Intelligence

The next phase for Orchid is addressing the ultimate edge case: what happens when the source API itself transmits flawed data. We plan to build adversarial anomaly detection layers that cross-reference multiple APIs (e.g., verifying Yahoo Finance against Moneycontrol) before the Planner is even allowed to see the numbers. Furthermore, we are looking to expand the MongoDB Atlas document logging to create a global, immutable ledger of all financial reasoning traces generated by the platform.

Built With

Share this project:

Updates