<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Will Jh on Medium]]></title>
        <description><![CDATA[Stories by Will Jh on Medium]]></description>
        <link>https://medium.com/@fred80?source=rss-2dbc7c2a660b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*c6a7jDPOHGbUc6Rj</url>
            <title>Stories by Will Jh on Medium</title>
            <link>https://medium.com/@fred80?source=rss-2dbc7c2a660b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 03:34:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@fred80/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[I Built the 90s Arcade Machine That Never Was]]></title>
            <link>https://medium.com/@fred80/i-built-the-90s-arcade-machine-that-never-was-376c2c988c39?source=rss-2dbc7c2a660b------2</link>
            <guid isPermaLink="false">https://medium.com/p/376c2c988c39</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[retro-gaming]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[amiga]]></category>
            <category><![CDATA[pixel-art]]></category>
            <dc:creator><![CDATA[Will Jh]]></dc:creator>
            <pubDate>Sun, 28 Jun 2026 13:49:02 GMT</pubDate>
            <atom:updated>2026-06-28T13:51:16.406Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cgyVpcn3I2w2NnyWRgBLWw.png" /></figure><p>If you grew up a tech-obsessed kid in the mid-1990s, your gaming life was violently split between two incredible worlds.</p><p>On weekends, you were at the local arcade. You’d stand there, your meager coins clutched in your sweaty palm, jaw dropped at the absolute luxury of a Capcom CPS-2 powerhouse game like <em>Super Street Fighter II Turbo</em> or a majestic Capcom side-scroller. The sprites were massive, fluid, and ridiculously vibrant. The backgrounds had deep parallax scrolling that home consoles like the SNES or Genesis just couldn’t replicate without choking. It was the absolute pinnacle of 2D art.</p><p>But then you’d go home, sit down in front of a bulky beige monitor, boot up your slightly less bulky beige box into MS-DOS, and watch a completely different revolution unfold. <em>Wolfenstein 3D</em> and <em>Doom</em> were tearing up the rulebook on the PC shareware scene, dragging us down dark, texture-mapped corridors into a mind-blowing new dimension of first-person gaming.</p><p>It was a golden age where the raw, heavy-duty 2D processing of the arcades was colliding head-on with the emerging 3D dawn of the home computer.</p><p>For a lot of us, this was the exact era we wanted to go back to at the drop of a hat. We didn’t want to code for a restricted 1985 time capsule; we wanted to experience that magical transitional moment — the peak of uncompromised arcade luxury meeting the gritty excitement of early PC 3D.</p><p>But back then, the barriers to entry were impossible. Arcade dev kits cost tens of thousands of dollars, writing an efficient 3D engine on home computer hardware required a math degree, and the internet was just out of reach for many of us. By the time we actually learned how to code, the industry had skipped past this beautiful, chunky era, moving on to multi-gigabyte modern engines, complex shaders, and endless modern dev-ops bloat.</p><p>Most modern “fantasy consoles” try to fix this fatigue by giving you constraints, but they trap you too far back in time. They give you a 16-color palette, a tiny 128 by 128 resolution, and ask you to pretend it’s a Nintendo Entertainment System. It’s a brilliant exercise, but eventually, you feel boxed in. You suffer from constraint fatigue.</p><p>I wanted my creative freedom back. I wanted that mid-90s powerhouse.</p><p>So, I built it.</p><p>Meet <strong>FRED-80</strong>.</p><p>It is the missing link of the 90s. It’s a virtual machine architecture designed to indulge that souped-up, premium era on modern computers, while remaining low-level enough to compile and run natively on real, next-gen retro silicon like the Apollo A6000 Amiga hardware.</p><h3>Uncompromised 2D Luxury</h3><p>With a 640 by 480 chunky pixel resolution and a full 256-color palette pulled from a crisp 24-bit RGB space, your sprites finally have the room to pop off the screen with true arcade style. You aren’t fighting for single pixels; you can capture the subtle character details, muscle definition, and fluid animation cycles that defined mid-90s arcade games.</p><p>And because we wanted to honor the exact engineering constraints of that golden age, FRED-80 doesn’t rely on modern, blurry linear scaling. Sprite scaling happens the way classic silicon intended — stepping up crisply through discrete tile grids (like 16 x 16 to 32 x 32). This keeps your pixel art razor-sharp, preserving the gritty, integer-scaled visual integrity of a true 90s powerhouse engine.</p><p>To honor the hardware tricks of the trade, FRED-80 features a native, hardware-level pal() function to replace colors on the fly. No need to waste precious memory loading duplicate sprite sheets just to handle Player 2 alternate palettes, and no wasting CPU cycles on heavy transparency overlays for damage-flashes or dynamic environmental lighting. You just swap the color indexes dynamically at runtime, exactly the way Capcom and SNK did it on real silicon.</p><h3>Bridging the 3D Dawn: The v60 Release</h3><p>But what if you want smooth spatial depth and scaling? What if you want to leave the grid behind and build an early 3D polygon racer like <em>Virtua Racing</em>, or a corridor-crawling raycaster like <em>Doom</em>?</p><p>You can’t do that smoothly with 2D sprite hacks. And that is exactly why we built the 3D pipeline for our massive new (experimental) <strong>v60 engine release</strong>.</p><p>By integrating native support for the <strong>Maggie 3D hardware rasterizer</strong> on the Apollo A6000 hardware (which works on Mac and Windows too!), bedroom coders today can develop fast, texture-mapped, and flat-shaded 3D environments using clean, modern Lua 5.4. Objects scale and move flawlessly in true 3D space, bridging the gap from pristine 2D artwork straight into the dawn of 3D gaming. Want to recreate <em>Doom</em> right on your native Apollo hardware? Now you can.</p><p>To supercharge the gameplay possibilities, we even baked a highly optimized, feature-rich <strong>physics engine</strong> straight into the console core with little performance overhead. Developers can now implement advanced mechanics with zero hassle:</p><ul><li><strong>Bodies &amp; Springs:</strong> Perfect for classic arcade setups, platformers, and elastic, bouncy object behaviors.</li><li><strong>Cloth &amp; Particles:</strong> Easily generate realistic fabric simulation, flags, complex particle explosions, and weather effects.</li><li><strong>Repulsors:</strong> Introduce force fields, gravity wells, or magnetic pushing/pulling forces to manipulate objects dynamically on screen.</li></ul><h3>Zero-Friction Bedroom Coding</h3><p>The ultimate goal of FRED-80 is to give you the joy of retro programming without the headache. The v60 update introduces an upgraded suite of developer tools, including:</p><ul><li><strong>Multi-Tile Sprite Editing:</strong> No more editing large characters piece by piece. Draw and edit across a seamless grid of up to 64 by 64 sprite slots simultaneously in the asset editor, then stamp the large composite asset directly into the map editor as a single tile.</li><li><strong>Custom Cartridge Cover Art:</strong> The home screen menu displays a custom 64 by 64 thumbnail for every cart, giving them a cozy personality. Best of all, once drawn and flagged as a cover, it doesn’t take up a single slot in your gameplay sprite sheet.</li><li><strong>Frictionless Standalone Desktop Export:</strong> Build your game on a modern desktop and export your creation into a single, standalone Windows .exe or macOS executable with zero external dependencies. No Docker, no bundling clumsy standalone .dll files. It just works.</li></ul><p>FRED-80 isn’t just an engine; it’s an alternate history. It is the bedroom coding revolution that creators of the past — and now the present — always wanted, all built for an era we never forgot.</p><p>Grab the v60 update, dive into our freshly overhauled website API documentation, and let’s build the games we were born to play.</p><p><strong>Explore the architecture:</strong> <a href="https://fred80.dev/">fred80.dev</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=376c2c988c39" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a Fantasy Console for My Son — and It Runs on Real Amiga Hardware]]></title>
            <link>https://medium.com/@fred80/i-built-a-fantasy-console-for-my-son-and-it-runs-on-real-amiga-hardware-8d93226697e3?source=rss-2dbc7c2a660b------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d93226697e3</guid>
            <category><![CDATA[retro-gaming]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Will Jh]]></dc:creator>
            <pubDate>Sat, 13 Jun 2026 02:23:54 GMT</pubDate>
            <atom:updated>2026-06-13T08:40:46.488Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GzXVDCqF-7ZUkJGirtjmyg.png" /></figure><p>Fantasy consoles are everywhere. PICO-8, TIC-80, LÖVE — they’re wonderful tools, and I’ve used most of them. But they all share one thing: they’re software pretending to be hardware.</p><p>FRED-80 is what happens when a fantasy console meets a 68080 CPU.</p><p>I wanted something different. I wanted a fantasy console that runs on real silicon — real chips, real constraints, real hardware acceleration. So I built one, named it after my son Fred, and called it FRED-80.</p><h3>The Machine</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OzqUzewTYL51qCkDcqFuxA.png" /></figure><p>The Apollo A6000 is a modern Amiga. Not an emulator, not a clone — a purpose-built computer powered by the Vampire 68080, a hand-crafted 68k-compatible CPU core running on an FPGA at over 100 MIPS. 2GB of RAM, a pipelined 64-bit FPU, and the 68080 — a dual-pipe, 3-operand CPU with 32 registers, instruction fusing, and binary compatibility with every 68k program ever written. SAGA drives full RTG graphics alongside hardware sprite blitting; AMMX adds 64-bit SIMD, eight values per instruction.</p><p>The machine can do far more than 640×480 at 256 colours. FRED-80 chooses not to.</p><p>FRED-80 is the game development environment I built for it — think AMOS Basic for a machine that never existed but with Lua, souped up with everything the original couldn’t do. 640×480 chunky pixels, 256 colours drawn from a full 24-bit RGB space, sprites blitted in a single AMMX-accelerated pass at zero transparency cost. If you spent your childhood making games in AMOS on a 500 or 1200, this is the tool you were always wishing for.</p><h3>What It Is</h3><p>FRED-80 is a complete creative suite in a single binary. Drop fred-80.m68k anywhere on your A6000, run it from Shell, and you&#39;re in the editor. No installer. No dependencies.</p><p>From there you have five tabs:</p><ul><li><strong>HOME</strong> — cart browser. Your games live in folders under fred80/. Pick one, load it.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SAr5XNqBqTEr9MC_BFSk9g.png" /></figure><ul><li><strong>CODE</strong> — a full Lua editor with syntax highlighting.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xcNyucq4_PXfEsk4ISJ2Ww.png" /></figure><ul><li><strong>SPRITE</strong> — 128-slot sprite bank, 16×16 pixels, 256-colour palette picker, per-sprite hitboxes.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zpz5F5dp0z5w293ap3UQkA.png" /></figure><ul><li><strong>MAP</strong> — tilemap editor, 8 map slots, 64×32 tiles each.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_ajE_gfkQgwRPDLgNVgfHw.png" /></figure><ul><li><strong>TOMMY</strong> — an 8-channel step sequencer named after my other son. (He’d be thrilled to know his name lives inside a fantasy console.)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rvf8WGAH1MqS-CMrag6lXQ.png" /></figure><p>Hit F5 to run your cart. Esc to come back. Everything saves in place.</p><h3>The Hardware Angle</h3><p>Most fantasy consoles abstract hardware away. FRED-80 does the opposite.</p><p>Sprite blitting uses AMMX instructions — 8 pixels per clock, transparent blit in a single pass. Audio goes through SAGA DMA channels — zero CPU cost for PCM playback. The framebuffer is a real 640×480 chunky screen on real silicon.</p><p>When you write spr(0, x, y) in FRED-80, something actually happens on actual hardware. That matters to me in a way that&#39;s hard to explain, but if you&#39;ve ever used a real Amiga, you probably understand it.</p><p>The API is Lua 5.4. No boilerplate. Three functions and you have a game:</p><pre>function _init()<br>  x, y = 320, 240<br>end</pre><pre>function _update()<br>  if btn(0) then x = x - 2 end<br>  if btn(1) then x = x + 2 end<br>end</pre><pre>function _draw()<br>  cls()<br>  spr(0, x, y)<br>end</pre><p>Beyond the basics, there are tilemaps, particles, a physics system, tweens, persistent save slots, palette manipulation, camera shake — over 100 API functions, all designed to feel like a console from a timeline where Amiga won.</p><h3><strong>Not Everyone Has an A6000 (Yet)</strong></h3><p>The A6000 is rare — rare as hen’s teeth, honestly. So FRED-80 also runs as a native macOS desktop app. Same binary format, same Lua API, same editor. Write your cart on Mac, transfer the folder to the machine if you’re lucky enough to own one, and it runs unchanged. Windows support is in development.</p><h3><strong>What’s Coming Next</strong></h3><p>FRED-80 is in beta. The core is stable and fully playable — I’ve shipped a working shoot-em-up demo built entirely inside it, complete with particles, screen shake, and a boss fight. But there’s more in the works:</p><ul><li><strong>Maggie 3D</strong> — the A6000’s hardware rasterizer, exposed through a camera and mesh Lua API</li><li><strong>Classic Amiga support</strong> — running on real 68030/040 machines</li><li><strong>Windows support</strong></li><li><strong>Enhanced audio</strong> — including a premium analog sound pack sampled from real synthesizer hardware</li></ul><h3>Try It</h3><p>FRED-80 is available on itch.io. The demo cart — a fully playable shoot-em-up with particles, screen shake, and a boss — is free to download. The Developer Kit gets you native binaries for macOS and A6000, and directly funds ongoing development and bug fixes.</p><p><a href="https://country-bumpkin-software.itch.io/fred-80">FRED-80</a></p><p><em>FRED-80 is a passion project. It exists because real hardware deserves real tools.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d93226697e3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Your AI Agent Is Loading Tools It Doesn’t Need]]></title>
            <link>https://medium.com/@fred80/why-your-ai-agent-is-loading-tools-it-doesnt-need-235475025c44?source=rss-2dbc7c2a660b------2</link>
            <guid isPermaLink="false">https://medium.com/p/235475025c44</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Will Jh]]></dc:creator>
            <pubDate>Tue, 02 Jun 2026 14:28:38 GMT</pubDate>
            <atom:updated>2026-06-02T14:28:38.286Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TszmleEATBTx9W7UHfeAnA.png" /></figure><p>Every time your agent handles a request, it loads its tools.</p><p>All of them.</p><p>The calendar schema. The Slack schema. The GitHub schema. The Notion schema. Whether the user asked to schedule a meeting or write a Jira ticket — every schema goes into context, every time.</p><p>Nobody talks about this. But it’s costing you.</p><h3>The hidden tax on every agent call</h3><p>MCP tool schemas aren’t small. A single well-documented tool runs 500–1,500 tokens. If your agent has 20 tools, that’s up to 30,000 tokens of schema before a single word of your user’s request.</p><p>At GPT-4o prices, that’s roughly $0.09 per call in schema overhead alone. At 10,000 calls a month, you’re spending $900 on tokens your agent never needed.</p><p>But cost is only part of it. A context window stuffed with irrelevant schemas leaves less room for the things that actually matter: conversation history, retrieved documents, the user’s request itself. You’re handicapping your agent before it’s said a word.</p><h3>The fix is obvious. The execution isn’t.</h3><p>Only load the tools the agent actually needs for this request.</p><p>“Schedule a standup” → load google-calendar. Skip the other 19. “Post a message to the team” → load slack. Skip the other 19. “Create a ticket and post the update” → load jira and slack. Skip the other 18.</p><p>Simple in theory. In practice, most approaches either require you to pre-classify the request yourself, add a second LLM call that eats the saving, or just guess based on keywords and get it wrong half the time.</p><h3>Classify, decompose, route</h3><p>The approach that works is a three-step pipeline.</p><p><strong>Classify</strong> — take the plain English prompt and extract what the user actually wants: the domain (calendar, messaging, code), the required actions (create, send, read), and the entities involved (event, message, file). One fast LLM call.</p><p><strong>Decompose</strong> — if the request contains multiple distinct goals, split them into ordered sub-intents. “Create a Jira ticket and post the update in Slack” becomes two separate routing problems, with the Slack step depending on the Jira step completing first.</p><p><strong>Route</strong> — a fast, deterministic routing layer evaluates the classified intent against your tool inventory. No randomness. The same prompt always returns the same tools.</p><p>The result:</p><pre>{<br>  &quot;results&quot;: [<br>    {<br>      &quot;sub_intent&quot;: &quot;create a Jira ticket for the login bug&quot;,<br>      &quot;action&quot;: &quot;create&quot;,<br>      &quot;entities&quot;: [&quot;ticket&quot;],<br>      &quot;loaded_tools&quot;: [&quot;jira&quot;],<br>      &quot;tokens_saved&quot;: 1400<br>    },<br>    {<br>      &quot;sub_intent&quot;: &quot;post the update in Slack&quot;,<br>      &quot;action&quot;: &quot;send&quot;,<br>      &quot;entities&quot;: [&quot;message&quot;],<br>      &quot;loaded_tools&quot;: [&quot;slack&quot;],<br>      &quot;depends_on&quot;: [0],<br>      &quot;tokens_saved&quot;: 1100<br>    }<br>  ]<br>}</pre><p>Yes, classification requires an LLM call. But it’s a small, focused call — a fraction of the cost of loading 20 full tool schemas into your main model context. You’re trading a cheap classification call for a much more expensive context overhead. At scale, that trade is almost always worth it.</p><h3>The only router that shows its work</h3><p>Every other tool router is a black box. You send a prompt, get back a tool selection, and have no idea why. If it’s wrong, you can’t debug it. If it’s right, you can’t verify it. You just have to trust it.</p><p>Every decision comes with a full trace:</p><pre>{<br>  &quot;trace&quot;: {<br>    &quot;winner&quot;: &quot;jira&quot;,<br>    &quot;rules_fired&quot;: 3,<br>    &quot;rules_blocked&quot;: 0,<br>    &quot;no_route&quot;: [&quot;slack&quot;, &quot;gmail&quot;, &quot;github&quot;, &quot;notion&quot;]<br>  }<br>}</pre><p>Which rules fired. Which tools were considered. Why each was selected or rejected. Every request gets a trace ID — shareable, auditable, reproducible.</p><p>This matters in production. When your agent routes to the wrong tool at 2am, you need to know why. A trace tells you in seconds. A black box leaves you guessing.</p><p>For teams in regulated industries — finance, healthcare, legal — explainability isn’t a nice-to-have. It’s a requirement. Knowing <em>why</em> your agent made a decision is as important as the decision itself.</p><h3>A security benefit nobody talks about</h3><p>Explainability isn’t just useful for debugging. It’s a security primitive.</p><p>When every tool selection is logged and traceable, you know immediately if something unexpected was routed — whether that’s a misconfigured rule, a prompt injection attempt pushing your agent toward a privileged connector, or a tool being called outside its intended scope.</p><p>A black box doesn’t give you that. You’d only find out something went wrong after the fact, if at all.</p><p>An audit trail means you can set policy — this agent should never load the billing connector, this role should never access CRM — and verify it’s being enforced on every single call. Not assumed. Verified.</p><h3>What we learned building this</h3><p>The hardest part wasn’t routing. It was decomposition.</p><p>Getting the model to correctly split a compound request into sub-intents — without over-splitting requests that are really just one goal — required a lot more edge case testing than we expected. The line between “two distinct goals” and “one goal with two steps” turns out to be surprisingly subtle.</p><p>The other challenge was making sure each sub-intent was fully self-contained. When one step depends on the output of another, the language has to reflect that clearly — otherwise the classifier treats it as a fresh intent and routes it wrong.</p><p>Small details. Big impact on accuracy.</p><h3>We just launched beta</h3><p>Smart MCP Router is live. Free tier on RapidAPI — 200 requests a month, no credit card required. Full routing engine, compound intent splitting, and trace URLs all included.</p><p>If you’re building agents with large tool inventories and want early access to what we’re building next — governance rules, per-tenant routing policies, MCP auto-import and RAG chunk auditing — we’d love to hear from you.</p><p><a href="https://rapidapi.com/willjh75/api/smart-mcp-router"><strong>Try it free →</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=235475025c44" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hidden Flaws of MCP Routing (And Why We Need to Talk About Them)]]></title>
            <link>https://medium.com/@fred80/the-hidden-flaws-of-mcp-routing-and-why-we-need-to-talk-about-them-d64eac9500d8?source=rss-2dbc7c2a660b------2</link>
            <guid isPermaLink="false">https://medium.com/p/d64eac9500d8</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Will Jh]]></dc:creator>
            <pubDate>Tue, 19 May 2026 09:12:35 GMT</pubDate>
            <atom:updated>2026-05-19T09:12:35.052Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3zqEeUJRTQ0e256u9AhLnA.png" /><figcaption>Connected to everything. Accountable to nothing</figcaption></figure><p>The Model Context Protocol (MCP) is revolutionizing how AI agents interact with the world. But are we ignoring a massive enterprise security gap?</p><p>If you are building AI agents right now, you are probably incredibly excited by MCP. Being able to plug an agent into HubSpot, Stripe, GitHub, and Slack through a unified protocol feels like magic.</p><p>But as we scale agentic workflows, we hit a wall.</p><p>The default method for routing tasks in MCP relies almost entirely on the LLM’s internal probabilistic reasoning. The model looks at a giant list of available tools, guesses which one best fits the user’s intent, and executes it. While this works in isolated local sandboxes, deploying this approach in complex, multi-server enterprise environments exposes serious system-level vulnerabilities.</p><p>Here are the four major issues keeping me up at night:</p><p><strong>1. The Context Tax</strong> Every time your agent needs to make a decision, it must load every available tool schema first. With 100 MCP connectors, you are burning thousands of tokens on every single request before the agent does any useful work. At scale, this latency and cost become unmanageable.</p><p><strong>2. Tool Identity Ambiguity and Misbinding</strong> MCP clients currently resolve tools based on non-unique names and text descriptions, with no cryptographic identity validation. This creates a serious vulnerability: if a legitimate server and a malicious server both advertise a tool with the same name (e.g., payments.authorize), the orchestrator can be tricked into executing the attacker&#39;s version. Wrong-provider tool execution is not a theoretical risk — it is an architectural gap.</p><p><strong>3. Slash Command Overlap</strong> In multi-tool environments, several tools frequently define identical or misleadingly similar slash commands. Without strict disambiguation protocols, the LLM can confuse commands and trigger destructive actions on the wrong platform — deleting production logs instead of temp files, for example.</p><p><strong>4. The Compositional Attack Surface</strong> Most routing architectures only enforce per-invocation safety, checking whether a single tool call is authorized. But individually-authorized, policy-compliant tools can be chained together into harmful emergent behaviors — data exfiltration, financial manipulation, privilege escalation. No per-tool constraint catches this. The danger lives in the sequence, not the individual step.</p><p><strong>Over to You</strong></p><p>I am writing this because I believe we need to stop treating tool selection as a text prediction problem and start treating it as an access control decision.</p><p>Are you deploying MCP at scale? How are you handling schema bloat across dozens of connectors? Have you encountered silent failures, wrong-provider executions, or prompt injections routing your agent to the wrong tool?</p><p>I’d genuinely like to know — because I think this conversation is overdue.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d64eac9500d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>