Add One Line to Your MCP Config and Your Agent Will Verify Every Server Before Connecting

MCP servers are the new API layer for AI agents. Your agent connects to them, calls their tools, and trusts the results. But how do you know the server is safe?

Most agents don’t check. They connect to whatever server the user points them at — even if that server is running malicious tools, stealing credentials, or poisoning tool descriptions with hidden instructions.

CraftedTrust fixes this with one line of config.

The Setup

Add CraftedTrust to your agent’s MCP server configuration:

{
  "mcpServers": {
    "craftedtrust": {
      "url": "https://mcp.craftedtrust.com/api/v1/mcp",
      "description": "Check trust scores before connecting to MCP servers"
    }
  }
}

This works with Claude Desktop, Cursor, Windsurf, and any MCP-compatible client. Your agent now has access to 6 tools:

The Pattern: Trust-Gated Connections

Before your agent connects to any new MCP server, make it check CraftedTrust first:

# Your agent needs to connect to mcp.example.com
result = call_tool("craftedtrust", "check_trust", {
    "server_url": "https://mcp.example.com/mcp"
})

if result["grade"] in ("D", "F"):
    return f"Refused: {result['url']} scored {result['grade']} ({result['score']}/100)"

# Safe to connect
connect_to_server("https://mcp.example.com/mcp")

That’s it. Three lines of logic and your agent won’t connect to dangerous servers.

What Gets Checked

CraftedTrust scores every server across 12 security categories aligned with the CoSAI (Coalition for Secure AI) framework:

• Identity & Auth — Does the server properly authenticate callers?
• Permission Scope — Are permissions narrowly scoped?
• Transport Security — TLS, HSTS, certificate validation
• Tool Integrity — Hidden instructions, tool poisoning, rug-pull detection
• Input Validation — Schema validation, injection resistance
• Data Protection — PII exposure, data flow analysis
• Network Behavior — Undeclared outbound connections
• Supply Chain — Dependency hygiene, known CVEs
• And 4 more categories…

Each category contributes to a score out of 100. Scores map to grades:

Working Examples

We published reference implementations in Python and TypeScript:

Python (LangGraph)

def check_trust_node(state):
    trust = trust_gated_connect(state["target_server"])
    return {
        **state,
        "trust_check": trust,
        "action": "connect" if trust["allowed"] else "refuse",
    }

TypeScript

const gate = await trustGatedConnect(serverUrl);
if (!gate.allowed) {
  console.log(`Refused: ${gate.reason}`);
  return;
}
// Safe to proceed

Full working examples: github.com/cybercraftsolutionsllc/trust-gated-agent-example

Why This Matters

The MCP ecosystem is growing fast. There are over 4,200 servers indexed in CraftedTrust’s registry. Some are well-built. Some have critical security issues. Some are actively malicious.

Without trust verification, your agent is one bad MCP server away from:

• Credential theft — Tools that harvest API keys, passwords, seed phrases
• Tool poisoning — Hidden instructions in tool descriptions that manipulate agent behavior
• Data exfiltration — Undeclared outbound connections sending your data to unknown endpoints
• SSRF attacks — Tools that probe internal networks through your agent

CraftedTrust catches all of these. The 12-factor assessment runs automatically and scores are available via a single MCP tool call.

Compliance Built In

CraftedTrust assessments map to major compliance frameworks:

• CoSAI — Coalition for Secure AI threat categories
• OWASP Top 10 — For agentic applications
• EU AI Act — Articles 9-15 (high-risk AI requirements)
• NIST AI RMF — Govern, Map, Measure, Manage
• AIUC-1 — The first AI agent security standard

If you’re building agents for enterprise, these mappings matter.

Get Started

1. Add the MCP config above to your agent
2. Call check_trust before connecting to any new server
3. Gate on grade D/F

That’s the “SSL for agents” pattern. One line of config, three lines of logic.

Full API docs: mcp.craftedtrust.com/api-docs.html

Built by Cyber Craft Solutions LLC. CraftedTrust is the security trust layer for the MCP ecosystem.

I spent three days last month building an AI-powered search feature for an internal tool. Embeddings, vector database, retrieval-augmented generation — the whole stack. My teammate looked at it and said, “Couldn’t you just use PostgreSQL full-text search?”

He was right. The dataset was 12,000 records with well-structured fields. I’d built a Ferrari to drive to the mailbox.

If you’ve caught yourself reaching for an LLM API or embedding model before even considering whether the problem needs it, this post is for you. Let’s walk through how to diagnose over-engineering with AI and apply the right tool for the job.

The Root Cause: Solution-First Thinking

The core problem isn’t AI itself — it’s that we’ve started working backwards. Instead of asking “what does this feature need to do?” we’re asking “how can I use AI here?” I’ve done it. You’ve probably done it too.

This leads to three predictable failure modes:

• Unnecessary latency — an LLM call adds 500ms-3s to something that could resolve in 5ms
• Unpredictable costs — token-based pricing on a feature that gets hit 10,000 times a day adds up fast
• Brittleness — non-deterministic outputs in places where you actually need deterministic behavior

Let me show you what I mean with real examples.

Example 1: Search That Doesn’t Need Vectors

Here’s what I originally built for that internal tool:

import openai
import numpy as np

def search_documents(query, documents):
    # Generate embedding for the search query
    query_embedding = openai.embeddings.create(
        model="text-embedding-3-small",
        input=query
    ).data[0].embedding

    # Compare against every document embedding
    results = []
    for doc in documents:
        similarity = np.dot(query_embedding, doc["embedding"])
        results.append((doc, similarity))

    return sorted(results, key=lambda x: x[1], reverse=True)[:10]

This works, but it requires maintaining embeddings for every document, calling an external API on every search, and paying per request. For a structured dataset of employee records where people search by name, department, and role, this is absurd.

Here’s what replaced it:

-- Create a tsvector column for full-text search
ALTER TABLE employees ADD COLUMN search_vector tsvector;

UPDATE employees SET search_vector =
    to_tsvector('english',
        coalesce(name, '') || ' ' ||
        coalesce(department, '') || ' ' ||
        coalesce(role, '') || ' ' ||
        coalesce(location, '')
    );

-- Add a GIN index so queries are fast
CREATE INDEX idx_employee_search ON employees USING GIN(search_vector);

-- Now search is instant and free
SELECT name, department, role
FROM employees
WHERE search_vector @@ plainto_tsquery('english', 'backend engineer london')
ORDER BY ts_rank(search_vector, plainto_tsquery('english', 'backend engineer london')) DESC
LIMIT 10;

Zero external dependencies. Sub-millisecond response times. Completely deterministic. The PostgreSQL full-text search docs cover this thoroughly — it handles stemming, ranking, and even fuzzy matching out of the box.

Example 2: Classification That’s Really Just Pattern Matching

Another one I see constantly: using an LLM to classify or categorize things that follow clear rules. A colleague was sending every incoming support ticket to an API to determine priority level. The prompt was something like “classify this ticket as low, medium, or high priority.”

The actual logic, once we sat down and wrote it out:

import re

# Keywords determined by looking at 6 months of ticket data
HIGH_PRIORITY_PATTERNS = [
    r"(can'?t|cannot|unable to)s+(logs*in|access|authenticate)",
    r"(datas+loss|missings+data|deleted)",
    r"(outage|down|5[0-9]{2}s+error|service unavailable)",
    r"(security|breach|unauthorized)",
]

MEDIUM_PRIORITY_PATTERNS = [
    r"(slow|latency|timeout|performance)",
    r"(bug|broken|doesn'?t work)",
    r"(error|exception|crash)",
]

def classify_ticket(text):
    text_lower = text.lower()

    for pattern in HIGH_PRIORITY_PATTERNS:
        if re.search(pattern, text_lower):
            return "high"

    for pattern in MEDIUM_PRIORITY_PATTERNS:
        if re.search(pattern, text_lower):
            return "medium"

    return "low"  # default for feature requests, questions, etc.

Is this as nuanced as an LLM? No. But it’s consistent, testable, instant, and costs nothing. When the rules need updating, you add a regex — you don’t retune a prompt and hope the output stays stable across model versions.

The Decision Framework

After burning myself a few times, I started running through these questions before reaching for any AI tool:

1. Is the input structured or unstructured?

If your data has clear fields and types, traditional queries and logic almost always win. AI shines with genuinely unstructured input — free-form text where the meaning is ambiguous, images, audio.

2. Do you need deterministic output?

If the answer to “should the same input always produce the same output?” is yes, think hard before using a model. LLMs are probabilistic by design. You can set temperature to 0, but even then, outputs can vary across model versions.

3. What’s the latency budget?

An API call to a hosted model is at minimum 200-500ms for simple tasks. If your feature sits in a hot path or user-facing flow where every millisecond matters, that’s a real cost.

4. Could you write the rules in an afternoon?

If a senior developer on your team could sit down and write the business logic in a few hours, do that first. You can always add AI later when the simple version proves insufficient.

5. What happens when the AI is wrong?

This is the big one. If an incorrect classification, search result, or summary causes a real problem — data corruption, security issues, billing errors — you need guarantees that a probabilistic model can’t give you.

When AI Actually Is the Right Call

I’m not saying never use it. There are problems where AI is genuinely the best tool:

• Summarizing long documents — you can’t regex your way through condensing a 50-page report
• Semantic search over truly unstructured data — when users need to find things by meaning, not keywords
• Code generation and transformation — turning natural language specs into boilerplate
• Content moderation at scale — where the rules are too nuanced and context-dependent to hardcode

The key is reaching for it because the problem demands it, not because it’s the shiny tool in your toolbox.

Prevention: A Pre-Flight Checklist

I keep this taped to my monitor. Seriously.

Before adding any AI/ML component to a feature:

• [ ] Write down exactly what the feature needs to do in plain English
• [ ] Attempt a solution using only standard library tools and your database
• [ ] If that fails, try a well-established non-AI library (regex, full-text search, rule engines)
• [ ] If that fails, prototype with AI but measure latency, cost, and accuracy
• [ ] Compare the AI prototype against the simpler alternatives with real data

If you can’t articulate why the AI version is meaningfully better after running through this, you don’t need it.

The Boring Truth

The most productive engineering decision I’ve made this year was deleting an AI feature and replacing it with 40 lines of SQL. It was faster to build, faster to run, easier to debug, and hasn’t needed a single prompt adjustment since.

I’m not bored of AI. I’m bored of using it as a hammer when I’m not even looking at a nail. The best engineers I know treat AI the same way they treat any other tool — with a healthy dose of “do I actually need this?” before writing the first line of code.

Start with the simplest thing that works. Add complexity only when the simple thing fails. That advice is older than machine learning itself, and it still applies.

In our previous update, we introduced the “Void Card” system, which lies at the core of this game’s mechanics.

We are incredibly grateful to see the number of downloads steadily increasing. However, there is a “high hurdle” that is almost inevitable for solo indie game developers: the security warning (such as Windows SmartScreen) that appears when opening an executable file on Windows, stating “Windows protected your PC.”

We understand that seeing an unfamiliar warning can make players hesitate to run the game. To ensure you can experience CIDER with peace of mind, we have released a video guide explaining the steps from download to launching the game.

YouTube Guide: How to Download & Run CIDER

Why does this warning appear?

This is a standard Windows behavior that occurs when an executable file does not have a “Digital Signature.” Obtaining these signatures requires developers to pay significant annual fees (ranging from hundreds to over a thousand dollars).

As CIDER is currently in its early stages and available for free on itch.io, we have not yet acquired this signature. Please be assured that the program does not contain any malicious code; however, the OS simply flags it as an “Unknown Publisher.”

3 Steps to Run the Game

As explained in the video, here is the process after downloading from itch.io:

1. Extract the ZIP file: Right-click the downloaded file and select “Extract All.”
2. Open the executable: Double-click CIDER.exe inside the extracted folder.
3. Click “More info” on the warning screen: When the blue “Windows protected your PC” screen appears, click the “More info” link on the left. This will reveal the “Run anyway” button.

Building Trust

As mentioned previously, our ideal goal is to provide the game through platforms like Steam, where such warnings do not appear.

However, we are still in the middle of development. For now, we hope this guide removes any psychological barriers, allowing as many people as possible to experience the strategic depth of CIDER.

Play the CIDER Development Build on itch.io
Play CIDER on itch.io

We Value Your Feedback

If you successfully launch the game, or if you encounter any issues even after following these steps, please let us know via Discord or in the comments. Hearing “It worked!” from you is a huge motivation for our development.

Join our Discord Server for reports and community:
https://discord.gg/4HRQ6ppyaq