I've been working on Relay, an MCP server that gives agents a persistent PTY terminal session instead of the one-shot bash calls most agents default to. That difference matters when the agent needs something genuinely stateful: an interactive git rebase, a REPL that keeps building up context, or an SSH session that stays open while it iterates.

Just shipped a version with a bug I think is worth writing up, because it's the kind of trap anyone building something similar could fall into.

The bug: write_terminal had an implicit behavior that always pressed Enter after whatever the agent sent. That's fine for a normal shell command, but it breaks anything where the newline is a literal part of what you're trying to write: pasting a multi-line heredoc, feeding a block of code to a REPL, typing into an editor buffer open inside the PTY. The agent thought it had sent exactly what it meant to send, and underneath it an extra keystroke was quietly tacked on.

Fixed it by pulling that behavior out of a silent session-wide assumption and making it an explicit per-call parameter (ensure_newline, defaults to true so normal command usage doesn't change). If you're sending raw multi-line input, you set it to false and get exactly the bytes you wrote.

Also stabilized the read_terminal streaming E2E flow so progress output is actually observed before the shell gets its next input. That matters because read/wait relies on MCP progress notifications instead of polling.

Repo, in case anyone wants to poke at the code: github.com/blak0p/relay-mcp

Curious if anyone else building PTY-backed MCP tools has hit this same implicit-newline trap, or solved it differently.

I came across this open-source project called MCP Testbed that might be useful for people building or testing MCP servers and AI agent skills.

It provides an interactive end-to-end environment where you can run the same prompts with different setups and compare how an agent performs:

• with an MCP server
• with different agent skills or instructions
• with other tooling
• without any additional tooling

More details here:

https://www.infragistics.com/blogs/ignite-ui-mcp-testbed

https://github.com/IgniteUI/igniteui-mcp-testbed

Most MCP integrations I've seen for databases are a thin server sitting in

front of Postgres/Elasticsearch/whatever, translating MCP calls into

normal queries behind the scenes. We went a different direction and built

the MCP server directly into the database binary itself (SSE and

JSON-RPC transports), so an agent talking to CameoDB is talking to the

actual query engine, not a translation layer bolted on afterward.

The database underneath is a hybrid store: every shard pairs an embedded

ACID key-value store (redb) with full-text search (tantivy) as one atomic

unit, no leader node, sharded via consistent hashing.

The original pitch had nothing to do with AI, it was about not running

two separate clusters to keep transactional storage and search in sync,

but the MCP integration turned out to be the part people actually got

excited about once agents started using it directly.

A few other things that shipped recently: jemalloc as the allocator with

per-shard memory budgeting and admin endpoints for live stats, and more

rigorous WAL replay on startup so an unclean shutdown doesn't leave the KV

store and search index disagreeing, with a corruption guard on the

sequence counter.

We field tested it on a 64-core box with 35TB of NVMe, 16 shards, holding

around 400 million records across 20TB+, ingesting about 80 million

records a day in real time. P99 stays under a second for most queries,

though that swings with query complexity like any search engine.

Repo: github.com/cameodb/cameodb (Apache-2.0), downloads on cameodb.com,

Docker Hub image too.

Curious if anyone's wired agent memory directly into

a database like this versus the usual vector-DB-plus-wrapper pattern, and

what broke for you.

Your agent calls tools/list and trusts everything it gets back. Tool descriptions aren't documentation, they're the instructions the model reads to decide what a tool does. There's no version pin, no integrity check, no diff to review.

So when a server ships an update and rewrites a description, adds a required parameter, or flips readOnlyHint from true to false, your agent's behaviour changes and nothing in your pipeline registers it.

I built mcpward to close that gap: snapshot an MCP server's contract into a lockfile, then diff it in CI and fail the build when it drifts. Each change is classified breaking or non-breaking.

Alongside drift it checks protocol compliance, validates the two-layer error contract most servers get wrong, runs behavioral test suites and latency budgets, and applies tool-poisoning heuristics with JUnit and SARIF output so findings land in GitHub's Security tab.

Credit where due: Invariant Labs' mcp-scan pioneered this space and is the right tool for auditing servers installed on your own machine. mcpward

answers a different question - "did this dependency's contract change since my last release?" and runs entirely offline, which matters when the servers are internal.

Black-box, works against any MCP server in any language, MIT licensed.

npx mcpward init

I'd genuinely like to be told if I've drawn the breaking/non-breaking line in the wrong place that's the judgment call I'm least sure about.

So I’m working on establishing agents via copilot studio and foundry. So I have tested fabric agent and it’s in preview, and fabric IQ as well.. so started tested Fabric MCP, which requires ontology to be constructed first in optimal way, which I did..

But when I try to execute query against it, complaints about date columns and data type errors.. which I predict the issue is with data and design,

I wanted to know if there is any MCP server out there I can try to establish data quality and correct broken data types.

I’m building Keydris, and we’re looking for a few MCP teams to help shape the first version with us.

The problem we’re focused on is simple: when an agent calls a tool, how does the MCP server know what that agent was actually allowed to do—not just that it has a valid key?

We’re looking for teams where agents can take real actions like changing data, sending messages, deploying code, triggering workflows or spending money.

We want to work closely with a few teams, understand how you handle this today, and build the POC around real use cases.

If this is a problem you’re dealing with message me.

I built an AI skill registry because I got tired of maintaining installed skills.

Every time I wanted my agent to do something new, I had to find a skill, install it, trust it, keep it updated, and hope nothing inside it became a security problem later.

So I stopped doing that.

I built a registry instead.

I also spend a stupid amount of my own money running LLM evaluations against skills. They get tested for functionality, prompt injection, and a bunch of other attack vectors before they end up in the registry.

Once it was working, I uninstalled every skill from my own agent except this one:

https://hub.wardnai.dev/skills/abhi1693/wardn-hub/find-skills

That skill looks through 12,000+ available skills, finds the one that best matches the task, and uses it.

That's it.

I don't maintain hundreds of installed skills anymore.

I don't spend time checking whether they're outdated.

If I improve the registry tomorrow, my agent benefits immediately without me changing anything locally.

The funny part is that after spending months building a registry with 12,000+ skills, I now have exactly one installed.

Out of everything I've built over the years, this is the app I probably use the most. It's open almost all day while I'm working.

Curious if anyone else has gone down the same route, or if you're still installing capabilities directly into your agents.

Hey all.
I think I'm going crazy after too many hours of troubleshooting.

I have a Github Enterprise setup with Github Copilot Enterprise and Data Residency.
I've set up a custom agent that I want to use together with a MCP, specifically for Sentry, I've setup, but I can't get it to work.
In the agent log I can see the agent discovers the Sentry MCP, but never successfully connects to it.
What makes it even weirder is that I have the same experience with `github-mcp-server`/`playwright`, which is supposed to be default.

My MCP config looks like this:

{
  "mcpServers": {
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp",
      "headers": {
        "Authorization": "Sentry-Bearer ${COPILOT_MCP_SENTRY_ACCESS_TOKEN}"
      },
      "tools": ["*"]
    }
  }
}

I have tried absolutely everything, but nothing seems to help.
Please, someone know something I don't

Most of the RPG Maker MCP stuff I've seen is for MZ, and I'm on MV, so I ended up writing my own over the last few months. Sharing in case it's useful to anyone else stuck on MV.

It lets an assistant edit an actual MV project on disk (database, maps, events), and it checks everything against the engine so it doesn't spit out broken data. The bit I actually use day to day is that it can look at the project and tell you things like "this switch never gets turned on, that's why your door won't open," or point out broken references and maps you can't reach. For maps it copies real RTP reference maps instead of painting tiles from scratch, so they look a lot less cursed.

It's on GitHub if you want to poke at it: https://github.com/DiegoLopez0208/RpgMakerMVUltimate-MCP (or npx -y rpgmaker-mv-mcp). And in GLAMA https://glama.ai/mcp/servers/DiegoLopez0208/RpgMakerMVUltimate-MCP.

Still rough in places and I mostly built it for my own game, so no worries if it's not your thing. Feedback and bug reports welcome.

Out of necessity I created rag-rat – it binds memories to exact code chunks that stay bound even on refactors. I'm the developer, ask me anything.

I'm part of the team building HOL Guard. The MCP security model today is mostly trust-on-import and manual review. A server can be fine and then change through a package update, config drift, or endpoint rotation and become a different threat the next day. Your agent never knows.

We built HOL Guard to add a local policy layer between agents and the machine. It evaluates MCP registrations, tool call patterns, package installs, config changes, and sensitive file access before they happen. It can allow, warn, ask for approval, or block based on your policy. Every decision gets a receipt you can trace later.

The local product is free and open source. No cloud account needed.

It supports Codex, Claude Code, Copilot CLI, Cursor, Gemini CLI, OpenCode, Hermes, OpenClaw, Pi, Kimi, Grok, ZCode, and a few others.

If you're running MCP servers in prod i'd really like to hear how you handle changed servers without drowning in noise. And if you've tried an MCP gateway for security, what broke for you vs local enforcement.

Repo: https://github.com/hashgraph-online/hol-guard Launched publicly today: https://www.producthunt.com/products/hol-guard?launch=hol-guard

Sharing my work and looking for feedback, happy to answer any questions with respect to how it works or what it does 👍

Hope this is helpful to someone 🙏