- Sponsor Sentinel IR development here: https://github.com/sponsors/jakcmencz?o=syg&sc=r
Right now, the dominant strategy for building AI coding agents is brute force.
When an agent needs to understand a project, we give it a tool to read files and let it dump thousands of lines of raw code directly into its memory. Because modern AI models boast massive memory limits, developers assume the AI will simply figure it out.
In reality, most AI agents operate like a messy teenager's bedroom. Everything is thrown onto the floor, and the agent has to dig through piles of clutter just to find one simple answer.
Verdict
Source (GitLab, Apache-2.0): https://gitlab.com/jakubrojicek11/sentinel-ir
npm: https://www.npmjs.com/package/sentinel-ir
Playground (runs in your browser): https://sentinel-ir-playground-dc30c8.gitlab.io/
The Brute-Force Trap
Feeding raw files directly to an AI feels easy during a quick test, but it breaks down quickly in real-world work:
• Wasted money and slow responses: Sending entire files burns through paid tokens and slows down every step.
• Lost in the middle: When given too much text at once, AI models lose focus, miss critical details, and start guessing things that are not true.
• Blindness to danger: An AI reading thousands of lines of raw text can easily overlook a hidden command that deletes files or sends data over the internet.
Imagine a doctor trying to treat a patient. Instead of looking at a clean summary card with a bright red warning for severe allergies, the doctor dumps an entire filing cabinet onto the floor and starts reading random papers from ten years ago. That is how we currently treat AI agents.
Give the Agent a Menu (Intermediate Representation)
When you walk into a restaurant, you don't want the chef to dump a sack of raw potatoes, uncooked meat, and spices onto your table. You want a menu—a clear summary of what is available and what allergens to watch out for.
Before an AI agent touches or modifies code, it needs that exact same kind of menu.
In software engineering, this summary is called an Intermediate Representation (IR). Instead of forcing an AI to guess the structure of raw JavaScript, TypeScript, Python, or Rust files, a strict, rule-based parser (tree-sitter) extracts the exact facts first:
• What exists: Functions, imports, exports, and how different parts of the project connect.
• What it touches: File system operations (fs.readFileSync), network calls (https.get), or system commands.
• Risk classification: Immediate warning labels marking files as low, medium, or critical risk before the AI ever attempts to run or change anything.
This division of labor changes everything. A strict, predictable tool maps out the code in milliseconds, while the AI focuses purely on high-level thinking using clean, verified facts.
Why WebAssembly and Local Execution Matter
Building a clean summary layer for AI agents is only half the battle. If that tool requires sending private source code to a third-party cloud—or relies on risky system-level install scripts—security teams will block it on day one.
This is why Sentinel-IR and sentinel-ir-mcp were built around three strict principles:
- Pure WebAssembly (WASM) execution: All code inspection runs inside an isolated, browser-grade sandbox. There are zero native binaries, zero hidden install scripts, and zero supply-chain surprises when you download the package.
- Read-only by design: The server inspects code without modifying your files or asking for administrator privileges.
- Zero-Knowledge and No-Login: Everything runs locally on your machine—or directly inside your web browser—without forcing you to sign into corporate cloud accounts or hand over your code to external servers. When an agent checks a project folder through sentinel-ir-mcp, it gets back a complete structural and risk summary in roughly 30 to 80 milliseconds. No raw file dumps. No wasted tokens. No guesswork.
Looking Ahead: Auditability Before the First Major Incident
Today, most teams are focused on making AI agents move fast. Very few are asking how they will audit what an agent saw—and why it made a specific decision—when something inevitably goes wrong in production.
Within the next year or two, as autonomous agents gain deeper access to databases, infrastructure, and live repositories, "dump everything into the prompt and hope for the best" will no longer be acceptable. Engineering teams and security auditors will demand predictable intermediate layers, sandboxed execution, and clear evidence trails.
Giving your agent a clean menu instead of a messy room isn't just about saving tokens today—it is about building AI systems you can actually trust tomorrow.
Try It Yourself (No Sign-In Required)
• Browser Playground (100% client-side WASM): gitlab.io
• Source Code (GitLab, Apache-2.0): https://gitlab.com/jakubrojicek11/sentinel-ir
• MCP Server on npm: npmjs.com
https://glama.ai/mcp/servers/jakcmencz/sentinel-ir-mcp
Independent Engineering Projects
Built as independent engineering experiments across AI, software analysis, security, and autonomous systems.
Evaluated by reproducible evidence, not by the number of layers.
Explore the projects:
Sentinel Ecosystem: AutoDoc-Sentinel, Sentinel-IR, Sentinel-IR-MCP and related tools.
Agentix Lite: Independent security and system-observation project.
Find the projects: GitLab repositories | NPM packages
Support the work: ⭐ Star the repositories on GitLab.
Connect: Follow me here on DEV Community or explore the Playground.
Each project is distributed under its own license. Check the corresponding repository or NPM package for licensing terms.
Copyright © 2026 jackymenCZ. All rights reserved. Written for the community.

![When is the memory location of `Box<[u8]>` guaranteed to remain stable?](https://emoji.discourse-cdn.com/twitter/wink.png?v=16)

