Rohit Tyagi

@dexhorthy read this cool article around code mode: x.com/_nishankj/stat…

Code Mode Deep Dive: 🦄 AI That Works #57 x.com/i/broadcasts/1…

great read! To every engineer out there, check it out! :)

@aiedge_ huge list, but discovery is the easy part. the hard part is making MCP tools reliable in real workflows, auth, permissions, state, and traces matter way more than having 100s of servers :)

A curated website with HUNDREDS of awesome MCP servers. Plug these into Claude, and it'll become 10x more powerful. One of my favorite AI resources to date. mcpservers.org

can someone rewrite my life in RUST so that clippy yells at me before I make terrible decisions?!!

@LangChain governance is where agent demos turn into infra. the tricky part is doing this in the same runtime where execution, creds, and traces already live, otherwise you just create another policy box next to the agent.

Introducing LangSmith LLM Gateway: The runtime governance layer for your agents. 💸 Enforce cost limits 🔒 Detect PII ✅ Act on violations …All without leaving LangSmith. Now in Private Beta langchain.com/blog/introduci…

@MATLAB the interesting shift is when the MCP server stops being just “tool access” and becomes execution policy too, what code can run, what gets tested, what state persists, what creds are exposed. that’s where agent infra actually gets opinionated.

The MATLAB MCP Core Server provides built-in tools that let agents run code, execute tests, perform static analysis, and detect installed toolboxes. Hear how MATLAB Copilot and the MATLAB Agentic Toolkit are changing the way people work and code 📽️

Sharing my thoughts around traces. I know thought pieces do not get a lot of traction but would love to get feedback! :D

@volosatovde i have no problems heheh

Hey builders: Does your product solve your own problem?

@ghumare64 x.com/tyagiro31/stat… wrote a little about this.

This is the most concrete thing I read today on why agent architecture matters in production, and the framing belongs in the harness debate alongside Anthropic's and Glean's. The frame: agent codebases that survive past six months don't survive because the team has more discipline. They survive because the architecture made the bad shape harder to write than the right one. That's a sharper claim than the "harness is the backend" version. It says the production failures are reproducible across teams because the abstractions allow them. The four canonical month-six failures Mike lists are worth memorizing: → Class-level mutable defaults shared between agents the moment a second user shows up → Tool functions that accept any string and return None on every kind of failure → Session memory mutated by an LLM-extracted string, silently poisoning every subsequent action → Multi-agent setups passing the parent's full conversation history to a sub-agent because it was the easiest wire-up Every team I've talked to in the last year has shipped at least two of these to production. The fix posts always say the same thing: validate inputs, isolate state, propagate spans, and bound your loops. Discipline. It gets forgotten in approximately every codebase. What Mike's arguing is the React-of-2013 move. jQuery apps scattered DOM state across whichever closure was handy. The discipline of "keep state in one place" was well understood and ignored everywhere. React made the discipline structural: the bug class went away because the framework stopped allowing the bad shape. Worker / Function / Trigger does the same thing one layer up. Class-level mutable state stops being expressible because worker invocations are stateless and persistent state lives in a memory worker addressed by namespace. Two agents in two processes can't share Python state because there is no shared Python state. Tool functions returning None on every failure stop being expressible because every function has a typed input/output schema the engine validates at the boundary. Wrong-shaped input gets rejected before the worker code runs. Failures return typed events with status and error type. Cross-agent history leakage stops being expressible because sub-agents are workers with their own context, called by function ID. The orchestrator passes a payload, not a conversation buffer. Agent Loops without step bounds stop being expressible because step bounds and timeouts are engine-level config, not something the agent author remembers to wrap. The Claude Code April 2026 postmortem is the cleanest evidence anyone's produced for why this matters. Three runtime changes, no model change, dropped median thinking length 73% and pushed retry rates up 80x. The community had to surface this from sampled session logs because most production systems don't ship that level of runtime telemetry by default. Making it default is the lever.

@daleverett I agree!

@tyagiro31 Cool! This shifts the focus from writing code to orchestrating state. The future of devtools isn't a better autocomplete; it's a transparent, replayable execution operating system. Excellent breakdown.

@hypergpt yep. most agent failures in prod look less like “the model got dumber” and more like bad execution boundaries, weak credential handling, and no traceability when a tool chain goes sideways.

Risks and Limitations of AI Agents Explained 🤖*⃣ AI agents are powerful but hallucinations, alignment failures, and security gaps can cause real damage. Here's what teams deploying agents in production actually need to know. Read more on HyperStore Blog 👉 store.hypergpt.ai/blog/risks-and…

good mental model. the gap i still see in most agent stacks is the execution layer between “who does the work” and “what gets connected”, isolated runtime, creds, traces, retries, and deterministic hooks are usually why things survive contact with real workflows. What do you think?

Most people are building AI agents… without understanding the architecture underneath them. That’s why their “agents” break the second things get complex. The biggest confusion right now: Skills ≠ MCP ≠ Hooks ≠ Subagents They solve completely different problems. Here’s the mental model that finally made it click for me: • Skills = WHAT the agent knows • MCP = HOW the agent connects • Hooks = WHEN automation happens • Subagents = WHO does the work Once you see this… modern agent systems start making way more sense. ━━━━━━━━━━━━━━━ 1️⃣ Skills → Reusable expertise Skills are not prompts. They’re modular knowledge systems loaded only when relevant. Think: • debugging playbook • code review checklist • growth analysis workflow • security audit procedure Instead of bloating context forever, the agent loads expertise on demand. This is architecture-level context engineering. ━━━━━━━━━━━━━━━ 2️⃣ MCP → The connectivity layer MCP is becoming the USB-C port for AI agents. It standardizes how models connect to: • GitHub • Slack • Databases • APIs • Internal tools 10,000+ MCP servers later… we’re watching the first real agent infrastructure layer emerge. Without MCP, agents stay trapped in chat. ━━━━━━━━━━━━━━━ 3️⃣ Hooks → Deterministic automation Hooks are underrated. They run OUTSIDE the model loop. Meaning: the AI doesn’t decide whether they execute. You do. Examples: • before tool call • after file edit • after deployment • on notification • on commit Hooks are what make agents reliable instead of “vibey.” ━━━━━━━━━━━━━━━ 4️⃣ Subagents → Specialized workers Subagents are not chats. They’re isolated workers with: • their own context • model • permissions • tool access One researches. One writes code. One reviews PRs. One deploys. Instead of one giant overloaded agent, you get coordinated specialists. This is where multi-agent systems actually become practical. ━━━━━━━━━━━━━━━ And above all of this? Plugins. A plugin bundles: → Skills → Hooks → MCP servers → Subagents → Tools into one installable system. Basically: Apps for agent runtimes. ━━━━━━━━━━━━━━━ The stack now looks like this: Plugins ↓ Skills ↓ MCP + Tools ↓ Subagents ↓ Hooks ↓ CLAUDE.md And CLAUDE.md stays always-on underneath everything. The persistent project brain. ━━━━━━━━━━━━━━━ A real workflow looks like this: → CLAUDE.md loads company context → Skill activates market-analysis workflow → MCP pulls data from Drive + GitHub → Research subagent gathers intelligence → Code subagent analyzes repos → Hook formats output + runs linter automatically No massive prompts. No copy-paste orchestration. No prompt spaghetti. Just systems. ━━━━━━━━━━━━━━━ The industry is over-obsessed with models. But the real moat is becoming: Knowledge architecture + orchestration design. That’s the actual shift happening right now. And most people haven’t noticed yet. ♻️ Repost if this clarified the stack for you.

@dotnet stable apis are nice, but the real line item is whether the runtime makes agents debuggable under failure. tracing + tool visibility + state inspection is what moves this from demo stack to something teams can actually operate.

Agentic AI is growing up. Microsoft Agent Framework 1.0 brings stable APIs, A2A cross‑runtime messaging, MCP tool discovery, graph‑based workflows, and a DevUI debugger for real‑time agent tracing. #dotNET + Python parity finally lands. Read 👉 buff.ly/NbKQBmG

@thdxr x.com/tyagiro31/stat… :p

since compaction is good now i've been keeping a session pinned per PR im working on and reusing it until it merges what's nice about this is i can see the cost of the session and understand what the feature cost me (pinning sessions is under an experimental flag)

@BDoma @mobbin the real mcp tax right now: install appears to work, but auth state / permissions / client handoff are flaky, so the whole stack feels broken. the protocol is only half the product, the connection lifecycle has to be boringly deterministic lol

@mobbin did not one single one of your employees check to make sure that the Codex Mac app worked with your MCP? I followed your command line install tools. The MCP shows up and says my subscription has expired, which is not true. There's no way to trigger authentication in the Mac app. Why didn't you provide proper instructions so we can use this? It's really not that hard. Test your work

haha a reminder that in AI world we are just reusing a lot of terms that were already defined in the software engineering world. For example: compaction is a term in LSM trees, which removes outdated data (tombstones) and rearranges data for faster query execution, crucial for maintaining optimal database health and efficiency. DO NOT FORGET THE ROOTS!! #systemdesign #softwarenengineering

@Hacubu @LangChain yep, once agents hit production, observability stops being “nice to have” and becomes the product. if you can’t trace tool calls, retries, and state transitions fast enough, debugging just turns into vibes.

Am on pat leave with severe FOMO from the amazing announcements @LangChain Interrupt this year! 🎉🎉 Personally most excited about SmithDB, our new bespoke database for agent observability. It's an order of magnitude faster across the board! Read more below - and we're hiring!

@badlogicgames AEE you use Nord as well! :p

because you played the long game, way before you knew there was a long game to play wrt being in the training data.