AI agents are extremely powerful systems. They can write code, automate workflows, analyze data, and interact with software environments. But how does that saying go again? With great power comes… well, you know the rest. As agents take on more complex and repetitive work, reliability matters more than raw capabilities. Without guard rails, even advanced systems can behave unpredictably. In this article, we’ll talk about why that happens and explain a few good ways to address it.
The Rise of the AI Agent
An AI agent is typically a Large Language Model paired with an execution environment. Instead of only generating text, the model can:
- Access files
- Execute code
- Call APIs
- Interact with operating systems
- Browse the web
This combination turns a chat interface into an operational system. Today, agents generally fall into three categories:
1. Coding Agents
Tools that help engineers write, debug, and execute code inside development environments.
2. Desktop Automation Agents
Agents that interact with operating systems and applications to automate user workflows.
3. Long-Running and Self-Improving Agents
Frameworks such as OpenClaw and Hermes support persistent memory and continuous execution. Hermes, developed by Nous Research, includes a built-in learning loop and persistent skill mechanisms designed to improve performance over time.
These systems operate beyond single-session conversations and can run continuously in the background.
The Core Problem: Consistency
The biggest challenge agents face is consistency. Large Language Models are inherently random. Given the same instruction twice, they may choose different approaches. That flexibility can be useful for more creative tasks but problematic for operational workflows.
Consider this task:
“Generate a weekly operations report by pulling metrics from three internal systems, summarizing performance, and emailing leadership.”
An unconstrained agent might:
- Query the systems in a different order each time
- Change how metrics are calculated
- Rename fields inconsistently
- Format the email differently week to week
The numbers may still be roughly correct, but the structure of the results shifts. Columns move. Definitions change. Leadership starts asking why this week’s “active users” metric differs from last week’s. Nothing is technically broken, the agent is still fulfilling the task it was given. But because the process isn’t fully predictable, it also isn’t scalable.
The good news is that there are ways of enforcing predictability and consistency, called guard rails. Guard rails constrain how agents operate without limiting what they accomplish. They define tool interfaces, enforce parameter requirements, and standardize outputs. This transforms unpredictable flexibility into reliable repeatability.
Two primary approaches address this need: Skills and the Model Context Protocol (MCP). Both extend agent capabilities while building in consistency from the ground up.
Guard Rail Approach 1: Skills
Skills are structured instruction sets implemented as text prompts, scripts, or capability definitions that guide an agent’s behavior for specific tasks.
They function like reusable procedures. For example:
- A weather skill might require the agent to use a specific CLI command.
- A geospatial validation skill might specify the exact validation script to run.
- A summarize skill that formats a document in a specific way.
Advantages:
- Simple to create
They can be quickly written as text prompts or short scripts without complex infrastructure. - Flexible
Skills are adaptable and can be easily modified to suit evolving agent needs or new tasks. - Easy to iterate
Their simplicity allows developers to quickly test and refine behavior for better performance. - Useful for rapid development
They provide a fast way to prototype agent capabilities before formalizing them.
Limitations:
- Security risks if poorly designed
Poorly implemented skills might inadvertently grant agents excessive permissions or access to sensitive system resources. - Tight coupling to local environments
Skills often rely on specific local configurations, making them difficult to share or deploy in different settings. - Fragile when APIs or tools change
If the underlying APIs or tools change, the skill scripts require manual, time-consuming updates. - Often lack standardized schemas
Without formal definitions, it is hard to ensure consistent input validation and output structure, leading to unpredictability.
Skills are effective, but informal. Their reliability depends on careful design and maintenance.
Guard Rail Approach 2: Model Context Protocol
The Model Context Protocol, or MCP, is an open standard designed to expose tools and data to language models in a structured way. MCP uses a client-server architecture with defined schemas for each tool. If an agent uses an MCP weather tool, it must pass structured parameters such as `location` and receives standardized JSON in return.
Transport Mechanisms MCP supports:
- stdio transport for secure local communication between the agent and tools
- HTTP-based transports, including Server-Sent Events, for remote tools
Advantages:
- Security by design
Agents can only access what the MCP server explicitly exposes. This limits unintended access to local files or system resources. - Schema enforcement
Tool interfaces are self-describing. If parameters change, updating the MCP server updates the interface the agent sees. - Reusability across agents
An MCP server can run locally or remotely. Multiple agents can access the same standardized tools. - Reduced hallucination risk
Structured responses reduce the likelihood that the model invents parameters or misuses APIs.
Limitations:
- More complex to build
Requires setting up a client-server architecture and defining strict schemas for all tools. - Rigid structure and operation
The use of defined schemas and required parameters limits flexibility in modifying tool behavior.
Skills vs MCP
Implementation at GEO Jobe
At GEO Jobe, we pride ourselves on being forward-thinking. We have successfully integrated AI technology into our day-to-day workflows, doing everything from hosting our own internal chat clients to empowering our developers with agentic tooling. Through this process, we have discovered that skills and Model Context Protocols (MCPs) play a critical role in enabling new workflows and making them more reliable.
One practical example is our custom ArcGIS System-of-Engagement (SOE) MCP. This server exposes tools that let agents automatically build custom ArcGIS Dashboards and StoryMaps from a single prompt.
For instance, passing the agent a prompt like this:
“Create a custom ArcGIS dashboard that gives me an executive overview of my customer data. Use this web map: 074d6ec084a649d698ec0cd1989aafdd”
Generates a fully configured dashboard in response:
Thanks to the guard rails provided by the MCP, this process is highly repeatable. The LLM does not have to struggle with the technical nuances of the ArcGIS ecosystem. Instead, the MCP enforces the required parameters and schema, freeing the model to focus entirely on building the dashboard.
In conclusion,
AI agents are moving from experimental tools to operational systems. As their responsibilities grow, consistency and security become critical. Without guard rails, agents may complete tasks but sometimes in inefficient or unpredictable ways. Structured mechanisms such as reusable skills or the Model Context Protocol allow agents to operate with repeatability and controlled access.
Guard rails do not limit capability. They make capability dependable.
For more information about our products, and improving your workflows, please reach out at connect@geo-jobe.com
About Our Company
GEO Jobe is a leading GIS software and geospatial solutions provider, serving more than 12,000 organizations globally. The company is most known for developing some of the industry’s most popular applications, including Admin Tools for ArcGIS, Backup My Org, Clean My Org, Manage My Attachments, and Symphony for ArcGIS.
GEO Jobe offers U.S.-based 24/7 Support for organizations using Esri’s ArcGIS© System. GEO Jobe also offers professional services focused on Esri’s ArcGIS System, including custom software development, enterprise solution implementation, data science and UAV data collection.
Founded in 1999, GEO Jobe has been in operation for more than 25 years and an Esri business partner since 2002, and is currently a Platinum Partner.
