Priyanshu Lohar

Priyanshu LoharJul 2, 2026

As I've continued researching, engineering, and developing intelligent systems under Aquilonis AI, one recurring challenge has influenced almost every architectural decision I've made: How do you build systems that can leverage Large Language Models without relying on them as the source of truth? While iterating through multiple revisions of one of the architectures I've been developing, I found myself redesigning not only the product itself but also the role AI should play within it. With each iteration, the architecture moved further away from the idea of an LLM making decisions and closer to the idea of an LLM participating within a deterministic system. That process led me to a simple conclusion: Perhaps we don't need to make LLMs deterministic. We need to design deterministic systems around them. Instead of asking an LLM to retrieve facts, perform calculations, apply business rules, make decisions, and explain everything, each responsibility can be assigned to the component best suited for it. • Verified data sources provide facts. • Deterministic code performs calculations. • Rule engines enforce business logic. • Validation layers verify outputs. • The LLM extracts structured information, explains results, and presents alternative perspectives. In this architecture, the LLM isn't responsible for truth. It's responsible for communication. Arriving at this architectural approach helped address what I considered one of the biggest bottlenecks in applying LLMs to high-trust domains: factual reliability. Rather than trying to eliminate hallucinations entirely, the system is designed to minimize the situations in which the model is allowed to invent, infer, or become the authority on factual information. I'm still refining and validating this approach, but I think there's an interesting discussion to be had around designing deterministic systems with probabilistic components, instead of expecting probabilistic models to behave deterministically on their own. I'd love to hear how others are approaching reliability, verification, and system architecture when building AI applications where correctness and auditability are essential.

Priyanshu LoharJul 23, 2026

The more I pull apart modern AI systems, the belief strengthens that the LLM is only one piece of the puzzle. At least my practice leans toward this way of orchestrating an AI system. The model generates tokens. Everything around it determines whether the overall system is actually useful: - Context construction - Memory - Tool selection - State management - Retrieval - Orchestration If those pieces are poorly designed, a stronger model rarely fixes the system. If they're well designed, even relatively small models become surprisingly capable. Model quality matters, but architecture compounds.

Priyanshu LoharAug 2, 2026

I've been experimenting on a taxonomy-driven retrieval system for LLMs. The original goal wasn't to build another RAG pipeline. It was to answer a question I kept coming back to: What should happen before an LLM generates an answer? A lot of that thinking changed when I started testing it on real-world documents instead of clean benchmarks. One example was a mutual fund factsheet extracted from a PDF. The first run produced a single chunk over 700,000 characters long. The issue wasn't the chunking algorithm itself. It was an assumption hidden inside it, the document was expected to have a single top-level heading. That assumption works for articles and documentation, but financial reports repeat the same structure over and over, with each scheme introducing its own section. After fixing that, another problem surfaced. The same fund name appeared as a top-level heading on one page and as a sub-heading on another. The content hadn't changed. The PDF extraction had. At that point, it became obvious that document hierarchy couldn't be treated as ground truth. The system had to identify entities, recognize repeated structures, and build relationships based on semantics rather than trusting formatting alone. That experience reinforced why the retrieval layer matters so much. The system I've been working on doesn't treat retrieval as simply finding the nearest chunks in an embedding space. It first organizes information into a semantic taxonomy, allowing queries to be routed through related concepts before ranking documents. On top of that, it maintains independent measures for relevance and trustworthiness, evaluates corroboration across sources, detects contradictions, and records why a particular result was surfaced. The language model is only responsible for understanding and generating language. Everything before that, how information is organized, how evidence is gathered, how conflicting sources are handled, and whether the retrieved context is actually complete, is a systems problem. The more I work on retrieval, the more convinced I become that reliable AI won't come from larger models alone. It will come from better information systems sitting behind them.