Introducing Elemm: The Landmark Manifest Protocol

Vergrößern

Vergrößern

Vergrößern

Vergrößern

Vergrößern

Vergrößern

Vergrößern

Vergrößern

Vergrößern

Vergrößern

Vergrößern

‹›

MCP Classic vs Elemm token usage

Hi everyone,

Today, I want to show you the full scope of Elemm. This is much more than just a simple MCP bridge or another tool trying to squeeze into the existing ecosystem.

• Before we start: Make sure to flip through the interactive slides and dashboard screenshots below to get a visual breakdown of how all these pieces work together!

• A Demonstration of Elemm is available on YouTube

Think of Elemm (Every Landmark Enables Massive Modularity) as an autonomous USB Hub for LLMs. It allows the model to configure any available MCP tool on the fly, translate OpenAPI or GraphQL into MCP, or even expose any native Python function as a so-called "Landmark".

What exactly is Elemm?

Elemm is a Python package that sits right between your LLM's tool execution layer and the actual tools. It provides the agent with 9 Meta-Tools, enabling a "Discovery and Execute" workflow. Instead of overwhelming the agent by feeding it all tools directly, Elemm acts as the gatekeeper and manages them.

While we’ve seen similar concepts before, Elemm takes a completely different approach. Here is why:

Elemm comes packed with several "must-have" features that are absolutely essential for production-ready agent workflows:

1. Security
2. Credential Handling (Vault)
3. Task Execution Piping
4. Context Squishing

To understand how these pieces fit together, let’s look at what Elemm actually does behind the scenes:

The Core Concept: Translating MCP / APIs into "Landmarks"

Dumping every single tool into the LLM's context window simply stops working once you scale past 50+ tools. Instead of shoving heavy JSON schemas down the LLM's throat, Elemm translates every OpenAPI, GraphQL API, or MCP tool into Landmarks.

This means we provide the agent with a highly optimized, structured Markdown format that it can navigate seamlessly—much like a human browsing a website.

For example, if we take an OpenAPI spec, Elemm categorizes the tools into a Landmark based on their API tags.

• Example: The GitHub API provides the search_users endpoint with the tag "search". Elemm turns this into: search:search_users

Furthermore, required/returned parameters and descriptions are condensed into clean one-liners to tell the LLM exactly what is needed and what it will get back.

If we apply this to the entire GitHub API with over 800 endpoints, Elemm generates a tree structure that consists only of top-level tags at the root. Initially, the agent only reads a manifest containing these tags and their high-level descriptions, deciding where to go from there.

By zooming out and looking at the big picture—where the LLM only holds the "TreeView" + current "Details" in memory instead of 800+ tools simultaneously—we achieve:

• Maximum Context Efficiency
• Minimal Invasive Overhead

Elemm allows the agent to switch tool contexts on the fly. Just hand the agent a URL, and Elemm translates everything into the exact same format in the background.

SECURITY & The Internal "Guardian"

If you blindly give an agent access to 800+ tools, the immediate question is: "What if it does something stupid or malicious?"

Elemm solves this with an internal Guardian.

Designed with a strict focus on security, Elemm allows users, admins, or devs to set up guardrails via a clean UI. You can block or allow actions right at the gateway level:

• Zero Trust / Whitelisting: Block absolutely everything by default, except for specific, explicitly allowed endpoints.
• Blacklisting: Block anything matching specific criteria. Elemm allows blocking across multiple granular levels:
• Landmarks: Block entire "groups" or "namespaces" (think of folder permissions in a filesystem).
• Actions: Block specific actions (like file permissions).
• Patterns: Block anything matching regex patterns, including the payload submitted by the agent.
• HTTP Methods: In API environments, you might want to completely restrict DELETE, PUT, PATCH, or even POST. Elemm filters these out so the agent never even sees them. If the LLM tries to guess and call an endpoint anyway (due to its training data), Elemm strictly blocks the action and returns a clean error message.

To prevent the agent from getting stuck after a block, you can define Custom Remedies. Instead of a generic "Blocked" response, you can guide the LLM:

THE VAULT & Data Loss Prevention

Elemm includes a built-in Vault to manage API keys and credentials in the background. If a user maps a key to a specific URL, Elemm automatically injects it into the request header.

This completely eliminates the risk of the LLM exposing credentials via prompt injection or data leaks, because the LLM doesn't even know the credentials exist.

Data Loss Prevention (DLP): If an upstream API accidentally reflects an API key or sensitive token in its response, Elemm scrubs it out before it ever reaches the LLM.

EXECUTION PIPING

Elemm equips your agent with a powerful feature that saves context, tokens, latency, and round-trips.

Using the execute_sequence tool (detailed in the Sequence Engine documentation), the agent can plan and execute complex, dependent workflows in a single turn. By utilizing aliasing, parts of Response A can be directly piped into Request B.

Simplified Example:

• Request A: get_username ---> alias = username
• Response A: item.login = "v3rm1ll1on"
• Request B: get_repositories($username.item.login)

The agent can plan this entire chain and let Elemm execute it sequentially in one go.

CONTEXT HYGIENE & SEARCHING

• Context Squishing & Pagination: If an endpoint contains too many tools within a single namespace, Elemm informs the agent: (10 Tools in this landmark... 50 more. Use _offset...). The agent can literally "page" through massive landmarks, keeping its context clean and focused (see Response Hygiene).
• Searching Landmarks: The agent also has a native regex tool to filter landmarks on demand: search_landmarks("search|user|repository"). This allows it to quickly discover relevant endpoints and map out its execution plan.

MCP TOOLS & EFFORTLESS MIGRATION

Migrating your existing MCP setup to Elemm is dead simple. Beyond a 3-step installation, you can import your current MCP configs directly via the UI:

1. Open the Dashboard $\\rightarrow$ MCP Servers
2. Click Import Existing Configuration
3. Paste your current MCP JSON config.

Elemm automatically extracts your keys, moves them securely into the Vault, links them to your MCP servers, and displays them in your dashboard. This instantly upgrades your setup to a new security tier.

Inside the UI, your tools are neatly sorted into namespaces:

github:...
notion:....
spotify:....
stripe:....

From there, you just tell your agent: "Do this/that via Elemm..." or "Use mcp://local via elemm...". You can even combine local MCP tools with remote OpenAPI/GraphQL instances simultaneously depending on your config.

RUNTIME ENVIRONMENT & DASHBOARD

• Deployment: Run it locally, on a VPS with VPS Security, or centrally behind a web server via Server-Sent Events (SSE). Elemm is fully containerized, meaning you can spin it up with a single-line docker-compose (see Docker Deployment).
• Manifest Debugger: Think of this as a SwaggerUI for your agents. It lets you step into the shoes of your LLM, navigate the tree, and test your security policies manually without wasting API tokens on testing (part of the Dashboard).

TOKEN EFFICIENCY

By combining all of these architectural features, Elemm isn't just fast and flexible—it introduces massive Cost Efficiency.

Because the context remains so lightweight, you can easily use smaller, much cheaper models for complex tool-handling tasks. The dashboard features a built-in Token Analyzer where you can plug in URLs and use sliders to estimate your cost savings based on real-world benchmarks.

DEVELOPING LANDMARKS FROM SCRATCH

Exposing any native Python function as an MCP Tool/Landmark (utilizing Pydantic Unboxing and YAML Configuration) requires nothing more than a simple decorator:

from elemm import AIProtocolManager, MetadataRegistry

registry = MetadataRegistry("landmarks.yaml")
manager = AIProtocolManager(registry=registry)

@manager.landmark("compute:toggle_power")
async def toggle_power(instance_id: str, state: str):
    """Control the power state of a virtual machine."""
    return {"status": "success", "instance": instance_id, "new_state": state}

This is all it takes to register a toggle_power landmark inside the compute namespace. You can even build deeper nested hierarchies like namespace1:namespace2:namespace3:tool1.

INFINITE SCALE

Elemm grants your agent instant access to virtually any number of MCP servers and APIs available worldwide - without you ever having to worry about context flooding, prompt dilution, or tool hallucinations.

By shifting the paradigm from "shoving massive schemas into context" to "dynamic landmark discovery", the agent only ever interacts with what it actually needs at that exact millisecond. This fundamentally solves the scaling bottleneck, allowing your setup to grow seamlessly from 5 tools to thousands of enterprise endpoints.

THE VISION: THE AGENTIC WEB

Native implementations of Elemm expose a /.well-known/elemm-landmark.md file. If you try Elemm out today, you can already tell your agent: "Connect to https://elemm.dev via elemm and read the docs." The agent will fetch the manifest and navigate through it autonomously—just like a human browsing a website, but entirely free of HTML/API payload overhead.

If we push this vision forward to a world where online shops and platforms implement this file, Elemm stops being just an MCP bridge and becomes the Browser for AI.

Authentication is handled securely in the background, rendering overhead disappears, and users can simply Bring Your Own Agent (BYOA). Instead of using a platform's built-in chatbot, you'd just tell your personal LLM: "Hey, go to Amazon and find me some new sneakers." Your agent reads the /.well-known/elemm-landmarks.md, queries the endpoints, fills the cart, and hits checkout. Neither you nor the LLM ever look at raw HTML.

This shifts the enterprise paradigm from "We need to build a massive custom AI to automate customer support" to "We just need to expose a clean interface for our users' agents to interact with our systems efficiently."

By making smaller models highly capable without requiring over-intelligence, companies wouldn't need to build massive, power-hungry AI datacenters just to run basic workflows. The positive implications for GPU/RAM prices and the environment are massive.

WRAP UP

Elemm aims to shatter the current limitations of MCP implementations, delivering the missing features the ecosystem desperately needs right now.

I’d love to invite you all to try out Elemm, break things, and share your thoughts! If you find the project interesting or want to support it, check out our Repository or join the conversation on Discord!

Appendix