Is this you? As a journalist, you can create a free Muck Rack account to customize your profile, list your contact preferences, and upload a portfolio of your best work.
Claim your profile
Articles by Shridhar Shah
15+ Bay Area Hackathons: The Prize Was Never the Prize
Fifteen-plus lost weekends, four wins, and one config value that took forty minutes to find. What hackathon life in Silicon Valley is actually like. Pulling into a tech campus at 8am on a Saturday with a laptop bag and no plan has a specific feeling to it. Half-empty parking lot. A t-shirt in a size somebody guessed. A room of people who decided sleep was optional. Most of what gets built won't survive Monday, and nobody minds. I've done 15+ across the Bay Area.
Stop Streaming Tools Through Your LLM
The 2026 shift from tool-calling to Code Mode: let the agent write one script instead of narrating fifty tool calls — and watch context tokens drop ~99%. TL;DR: The classic agent loop loads every tool definition into the context window and pipes every intermediate result back through the model. Connect a few dozen tools and the context is full before the user even speaks.
The Agent That Answers Before You Ask
Sleep-time compute: split the budget so a background worker does the predictable thinking while idle — and the user waits far less when they finally ask. TL;DR: Most agents only think when a request arrives — the user waits and you pay full latency every time. But between sessions there's idle capacity, and many queries are predictable variants of past ones over context that barely changes.
Stop Making Your Agent Wait: Branch Prediction for Tool Calls
Speculative tool execution guesses the next tool while the model is still reasoning, runs it in parallel, and hides the latency — discarding the guess when it's wrong. TL;DR: An agent's think→act→observe loop is serial, so it burns a huge share of wall-clock sitting idle while a tool runs. Speculative tool execution borrows branch prediction from CPUs: a cheap predictor guesses the next tool call and runs it during the model's reasoning.
Your Agent Has a Bug You Can't Reproduce. Here's How to Catch It.
Deterministic simulation testing drives every fault, clock, and random choice from one seed — so a flaky, once-in-production agent bug becomes a reproducible artifact you can shrink to one line. TL;DR: The worst agent bugs only appear under a specific interleaving of faults — a tool fails right after a side effect, a retry fires, and money moves twice. Happy-path tests miss it, and when it hits production you can't reproduce it.
One Long Prompt Shouldn't Freeze Everyone's Tokens: Prefill/Decode Disaggregation
An LLM request is two workloads in a trench coat — a heavy, bursty prefill and a stream of tiny latency-sensitive decodes. Running them on the same engines lets one big prompt stall everyone. Splitting them fixes it. TL;DR: Every LLM request is two very different jobs. Prefill reads the whole prompt — heavy, bursty, and slow for long contexts. Decode then emits tokens one at a time — tiny, but latency-sensitive.
I Gave 3 AI Agents a Decaying Notepad and They Built a Culture
One shared memory that keeps fading, three minimal agents, no boss — and a story that outlives every note that carried it. TL;DR: Give a few bare-bones agents nothing but a shared notepad that constantly fades, and they spontaneously build a culture — a story they keep alive together, long after any single note has decayed to nothing. No coordinator, one tiny rule. Runs on a laptop. The setup Three agents share one whiteboard. Every tick, everything on it fades; a note left alone dies in ~4 ticks.
AI Agents That Live Inside a Dreamed-Up World
An agent watches a game, learns to hallucinate the next frame, then plays inside its own dream — but only the model that knows players react to each other stays true. TL;DR: The hottest idea in agents right now: don't feed them the real world — let them dream it. An agent watches some footage, learns to hallucinate the next frame, and practices inside its own head. I built a tiny one, and found the catch: a dream only stays true if it knows the players react to each other. Runs on a laptop.
I Watched Two AI Agents Invent Their Own Language
No shared words, no dictionary โ just two agents that negotiate a private code from scratch and hit ~97%. TL;DR: Give two AI agents a reason to coordinate and they'll make up their own language โ one we never designed. I built the tiniest version: two agents, zero shared words, and from "did we understand each other?" alone they invent a private code and hit ~97%. Runs on a laptop, no API key.
How Do You Trust an AI Agent With Your Money? You Don't — You Check Its Receipt
Cryptographically verifiable agent behavior: swap, edit, or forge a step and it's rejected. TL;DR: As we let AI agents do real things (issue refunds, move data, call APIs), "just trust it" stops being good enough. The fix: the agent hands you a tamper-proof receipt that proves it followed the approved rules and didn't fake anything. I built a demo — change the rules, edit a step, or fake the signature, and the check fails every time. ~120 lines, normal everyday crypto, no API key.
I Built an AI Agent That Gets Curious On Its Own
Active inference: curiosity emerges for free from minimizing surprise — 48% vs 100% on a foraging task. TL;DR: Most AI agents chase rewards — they pick whatever action scores the most points. I tried a different, brain-inspired goal: avoid surprises. Something neat happened — the agent became curious without being told to. It goes looking for information before acting, and that takes it from 48% to 100% on a simple task. ~100 lines.
Do AI Agents Need to Sleep? I Built One That Does
A sleep-like phase that consolidates noisy daily experience into durable memory — 75% vs 100% recall. TL;DR: There's a wave of 2026 research giving AI a "sleep" phase — time spent not answering questions, just tidying up what it learned that day. I built a 90-line demo of the idea. The agent that "sleeps" remembers 100% of what it learned. The exact same agent without sleep remembers only 75% and gets confused by bad info. Runs on a laptop.
Agents Are Learning to Write Their Own SKILL.md Files
The Agent Skills open standard today, and the 2026 research on agents that write their own skills. TL;DR: In late 2025, "Agent Skills" became a thing — a dead-simple way to teach an AI agent a task: a folder with a SKILL.md file (some instructions in Markdown). It's already an open standard. The wild part is what's coming next: agents that write their own skills.
Can an AI Agent Pass the Test We Give 4-Year-Olds?
Theory of Mind and the Sally-Anne false-belief test, in ~60 lines of Python. TL;DR: There's a famous test that kids pass around age 4. It checks whether you understand that other people can believe things that aren't true. I built two AI agents: one that only knows "what's actually happening" (fails, like a toddler) and one that keeps track of what each person believes (passes). It's ~110 lines, and it's the foundation for agents that can actually work together.
I Built an AI Agent That Rewrites Its Own Code (in ~150 lines)
A tiny Darwin Gödel Machine that edits itself and keeps only changes that verifiably score higher. TL;DR: I built a small program that improves itself. It looks at the tasks it's failing, edits its own code to fix them, and keeps a change only if the change actually makes it score better on a test. It goes from passing 1 of 8 tasks to 8 of 8 — and nobody wrote those fixes but the program itself. It runs on a laptop in under a second. No fancy hardware, no API key.
Show More
loading
Actions
Is this you?
As a journalist, you can create a free Muck Rack account to customize your profile, list your contact preferences, and upload a portfolio of your best work.Get in touch with Shridhar
Contact Shridhar, search articles and posts on X, monitor coverage, and track replies from one place.
Learn more about Muck Rack