Yash Shah
Founder & MCP Developer
New City, New York, United States
Actions
Yash Shah is the founder of Avarieux, a multi-source AI research platform for self-directed investors. He was previously a founding engineer at Papex, where he built production AI/ML systems alongside the founding team. He's the author of four open-source MCP servers cited by Pulse and Lobe Hub, with two PRs in code review at Anthropic's official modelcontextprotocol/servers repository. He holds an MS in Data Science from NJIT.
Area of Expertise
Topics
Four MCPs in Two Months: Lessons From a Solo Developer Shipping Agentic Infrastructure
The frameworks make it look easy. LangChain, CrewAI, Autogen, Model Context Protocol — the docs all show you the happy path. The reality of shipping a production AI agent — with real users, real rate limits, real concurrency, real failure modes — is something else.
In the last two months I shipped four open-source MCP servers covering financial filings, prediction-market data, real-time audio analysis, and stealth web browsing. Two PRs are in code review at Anthropic's official modelcontextprotocol/servers repo. The packages have crossed 5,000 NPM downloads. The same architectural patterns and failure modes apply whether you're building on MCP, CrewAI, or rolling your own agent loop.
This is the talk I wish someone had given me on day one. We'll cover the three production bug shapes that nearly killed each server (the asyncio.run inside async runtimes that crashes silently, the Promise.all vs Promise.allSettled choice that determines whether one failed source poisons your whole response, the print() statement that corrupts stdio JSON-RPC). The token-economics decisions that turn an expensive agent into a cheap one (representation choice, response shape, cache strategy). And the README-as-architecture principle — why what you say about what your agent isn't matters more than what you say about what it is.
If you're about to ship your first production agent or you're a few weeks into one and wondering why it keeps falling over, this talk has the lessons that took me two months of compressed building to learn.
Building Hallucination-Resistant AI Agents for High-Stakes Domains
We built an AI research tool that quotes specific numbers — stock prices, P/E ratios, filing dates, insider transaction sizes — back to retail investors. Every wrong number is a legal problem, a reputational problem, or both. After watching off-the-shelf LLMs confidently hallucinate revenue figures from 10-K filings, we built a grounding verifier that audits structured claims against the underlying tool output before the response leaves the server. Unverifiable claims get flagged and surfaced to the user, never silently passed.
This talk is the production walkthrough at the level of architecture, not implementation. The three failed approaches we tried first (regex pre-filters, LLM-as-judge audits, strict schema validation) and why each broke in instructive ways. The fail-closed instinct that took six weeks to internalize. The principled scope of structured verification — what kinds of claims a per-claim verifier can defend, and what kinds it structurally cannot. The specific failure category we caught early, including the time the model invented an entire insider sale that never happened.
By the end you'll know how to think about building a verifier for your own production agent, what the architectural tradeoffs are, and the specific bug shapes that will bite you in week three. If you've ever shipped an AI feature and then prayed nobody quoted it back to a regulator, this talk is for you.
Shipping Production AI Agents at Speed: What Breaks, What Works, What the Spec Doesn't Tell You
The frameworks make it look easy. LangChain, CrewAI, Autogen, Model Context Protocol — the docs all show you the happy path. The reality of shipping a production AI agent — with real users, real rate limits, real concurrency, real failure modes — is something else.
In the last two months I shipped four open-source MCP servers covering financial filings, prediction-market data, real-time audio analysis, and stealth web browsing. Two PRs are in code review at Anthropic's official modelcontextprotocol/servers repo. The packages have crossed 5,000 NPM downloads. The same architectural patterns and failure modes apply whether you're building on MCP, CrewAI, or rolling your own agent loop.
This is the talk I wish someone had given me on day one. We'll cover the three production bug shapes that nearly killed each server (the asyncio.run inside async runtimes that crashes silently, the Promise.all vs Promise.allSettled choice that determines whether one failed source poisons your whole response, the print() statement that corrupts stdio JSON-RPC). The token-economics decisions that turn an expensive agent into a cheap one (representation choice, response shape, cache strategy). And the README-as-architecture principle — why what you say about what your agent isn't matters more than what you say about what it is.
If you're about to ship your first production agent or you're a few weeks into one and wondering why it keeps falling over, this talk has the lessons that took me two months of compressed building to learn.
How We Stopped Our AI From Lying About Money: A Production Story
We built an AI system that quotes specific numbers — financial figures, regulatory filing data, transaction details — back to users in a regulated domain. Every wrong number is a legal problem, a reputational problem, or both. After watching off-the-shelf LLMs confidently invent revenue figures from public filings, we built a grounding verifier that audits structured claims against the underlying tool output before the response leaves the server. Unverifiable claims get flagged and surfaced; never silently passed.
This is the practitioner walkthrough — what we tried first that didn't work, why each approach broke in instructive ways, and what the fail-closed instinct really means when wrongness is expensive. The three failed approaches before we landed on what works: regex pre-filters that missed semantic claims, LLM-as-judge audits that just doubled the cost of being wrong, and strict schema validation that broke as the response space evolved. The principled scope of structured verification — what kinds of claims a per-claim verifier can defend, and what kinds it structurally cannot. The specific failure category we caught early, including the time the model invented an entire insider sale that never happened.
By the end you'll have a concrete framework for thinking about verification in your own production AI systems — what the architectural tradeoffs are, what bug shapes to expect in week three, and the difference between bolt-on hallucination mitigation and architectural verification. The case study is finance, but the principles generalize to any domain where AI output is consumed as fact.
If you've ever shipped an AI feature and then prayed nobody would quote it back, this talk is for you.
The Grounding Verifier: How We Stopped Our AI From Lying About Money
We built an AI research tool that quotes specific numbers — stock prices, P/E ratios, filing dates, insider transaction sizes — back to retail investors. Every wrong number is a legal problem, a reputational problem, or both. After watching off-the-shelf LLMs confidently hallucinate revenue figures from 10-K filings, we built a grounding verifier that audits structured claims against the underlying tool output before the response leaves the server. Unverifiable claims get flagged and surfaced to the user, never silently passed.
This talk is the production walkthrough at the level of architecture, not implementation. The three failed approaches we tried first (regex pre-filters, LLM-as-judge audits, strict schema validation) and why each broke in instructive ways. The fail-closed instinct that took six weeks to internalize. The principled scope of structured verification — what kinds of claims a per-claim verifier can defend, and what kinds it structurally cannot. The specific failure category we caught early, including the time the model invented an entire insider sale that never happened.
By the end you'll know how to think about building a verifier for your own production agent, what the architectural tradeoffs are, and the specific bug shapes that will bite you in week three. If you've ever shipped an AI feature and then prayed nobody quoted it back to a regulator, this talk is for you.
The Token Economics Stack: How Production AI Costs Quietly Explode (and How to Stop It)
The default way most teams build with LLMs makes the cost spiral inevitable. Raw context dumped into prompts. Whole HTML pages returned from tool calls. Cache-busting response shapes. Recursive agent loops that retry on cosmetic errors. The unit economics looks fine in the demo and catastrophic at scale.
This talk is a field report on the architectural decisions that determine whether your production AI agent costs five cents per query or one-tenth of a cent — an order of magnitude difference driven entirely by representation, shape, and cache strategy. I'll walk through the before/after on a real production MCP server where the architectural shift from raw HTML returns to structured representations cut response payloads by an order of magnitude — and what that meant for both latency and cost.
We'll cover: the representation choice that's hidden in every tool design and determines token efficiency more than prompt engineering ever will; why agent retry logic compounds cost geometrically and how to bound it; the cache strategy that works for agentic workflows (it's not the cache strategy that works for traditional web apps); and the audit pattern that lets you actually see where your tokens are going in a long-running agent run.
This isn't about prompt optimization or model choice. It's about the architectural primitives underneath both, which most teams aren't thinking about yet. If you're scaling a production AI product and your CFO is starting to ask uncomfortable questions about API spend, this talk is for you.
Verification Before Interpretation: MCP Patterns for Agentic Finance Tools That Can't Hallucinate
Large language models are fluent, confident, and perfectly willing to invent a P/E ratio or cite a filing that doesn't exist. In regulated finance, that isn't a quirk — it's disqualifying. This talk shares the open-source patterns I developed building MCP (Model Context Protocol) servers that connect AI agents to primary financial sources: SEC EDGAR filings, XBRL fundamentals, FRED macro data, insider and congressional trades.
The core idea is verification before interpretation. I'll walk through concrete, reusable patterns: grounding every model claim against a primary source before it reaches a user; failing closed when a figure can't be tied to a document; designing the model layer to be swappable so no single provider is load-bearing; and structuring tool outputs so an agent reasons over cited facts rather than its own memory.
Attendees will leave with practical architectural patterns for building trustworthy agentic finance tools on open standards — applicable whether you're deploying internally or contributing to open projects. Code and server examples are public.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top