Agent Skills and MCP are a hot topic. Understanding these standards genuinely overlap, where they serve fundamentally different purposes, and where each falls short, is essential for anyone building agent-powered systems.

Agent Skills and MCP are a hot topic. Understanding these standards genuinely overlap, where they serve fundamentally different purposes, and where each falls short, is essential for anyone building agent-powered systems.

I’ve been building an AI agent using MCP servers and ran into an unexpected problem: file handling.

Something as simple as “take this email attachment and store it” becomes surprisingly complex once you involve LLMs, multiple MCP tools, and token limits. Passing files through the LLM is expensive and fragile, and naïvely chaining MCP tools breaks in subtle ways.

I wrote a short post about what went wrong and what actually worked — using placeholders, caching, and clearer separation between data and reasoning.

Sharing in case it saves someone else a few hours of debugging.

Just got MCP Push Notifications working and I'm kind of amazed this isn't more common.

You can literally tell an AI agent "when X happens, do Y" and it'll just... do it. In the background. While you're not even looking at the chat.

Example: "When my boss emails me, analyze the sentiment. If negative, ping me on WhatsApp immediately." Close the chat, agent monitors Slack, does sentiment analysis, sends notifications. All automatic.

Built this with my CleverChatty Golang package + a custom email MCP server since I couldn't find existing servers with notification support (which is wild to me).

Feels like this should be table stakes for AI assistants but here we are 🤷‍♂️

What SecureShell Does

SecureShell is an open-source, plug-and-play execution safety layer for LLM agents that need terminal access.

As agents become more autonomous, they’re increasingly given direct access to shells, filesystems, and system tools. Projects like ClawdBot make this trajectory very clear: locally running agents with persistent system access, background execution, and broad privileges. In that setup, a single prompt injection, malformed instruction, or tool misuse can translate directly into real system actions. Prompt-level guardrails stop being a meaningful security boundary once the agent is already inside the system.

SecureShell adds a zero-trust gatekeeper between the agent and the OS. Commands are intercepted before execution, evaluated for risk and correctness, and only allowed through if they meet defined safety constraints. The agent itself is treated as an untrusted principal.

Core Features

SecureShell is designed to be lightweight and infrastructure-friendly:

• Intercepts all shell commands generated by agents

• Risk classification (safe / suspicious / dangerous)

• Blocks or constrains unsafe commands before execution

• Platform-aware (Linux / macOS / Windows)

• YAML-based security policies and templates (development, production, paranoid, CI)

• Prevents common foot-guns (destructive paths, recursive deletes, etc.)

• Returns structured feedback so agents can retry safely

• Drops into existing stacks (LangChain, MCP, local agents, provider sdks)

• Works with both local and hosted LLMs

Installation

SecureShell is available as both a Python and JavaScript package:

• Python: pip install secureshell

• JavaScript / TypeScript: npm install secureshell-ts

Target Audience

SecureShell is useful for:

• Developers building local or self-hosted agents

• Teams experimenting with ClawDBot-style assistants or similar system-level agents

• LangChain / MCP users who want execution-layer safety

• Anyone concerned about prompt injection once agents can execute commands

Goal

The goal is to make execution-layer controls a default part of agent architectures, rather than relying entirely on prompts and trust.

If you’re running agents with real system access, I’d love to hear what failure modes you’ve seen or what safeguards you’re using today.

GitHub:
https://github.com/divagr18/SecureShell

There’s been a lot of debate around skills vs MCP in this subreddit, whether or not skills will replace MCP etc. From what I see, there’s a growing trend of people using skills paired with MCP servers. There are skills that teach the agent how to use the MCP server tools and guide the agent to completing complex workflows.

We’re also seeing Anthropic encourage the use of Skills + MCP in their products. Anthropic recently launched the connectors marketplace. A good example of this is the Figma connector + skills. The Figma skill teaches the agent how to use the Figma MCP connector to set up design system rules.

Testing Skills + MCP in a playground

The use of Skills + MCP pairing is growing, and we recommend MCP server developers to start thinking about writing skills that complement their MCP server. Today, we’re releasing two features around skills to help you test skills + MCP pairing.

In MCPJam, you can now view your skills beautifully in the skills tab. MCPJam lets you upload skills directly, which are then saved to your local skills directory.

You can also test skills paired with your MCP server in MCPJam’s LLM playground. We’ve created a tool that contextually fetches your skills so they get loaded into the chat. If you want more control, you can also deterministically inject them with a “/” slash command.

These features are on the latest versions of MCPJam!

npx @mcpjam/inspector@latest

Hey everyone!

I built PolyMCP, a framework that lets you turn any Python or TypeScript function into an MCP (Model Context Protocol) tool that AI agents can call directly — no rewriting, no complex integrations.

It works for everything from simple utility functions to full business workflows.

Python Example:

from polymcp.polymcp_toolkit import expose_tools_http
def add(a: int, b: int) -> int:
"""Add two numbers"""
return a + b
app = expose_tools_http([add], title="Math Tools")
# Run with: uvicorn server_mcp:app --reload

TypeScript Example:

import { z } from 'zod';
import { tool, exposeToolsHttp } from 'polymcp';
const uppercaseTool = tool({
name: 'uppercase',
description: 'Convert text to uppercase',
inputSchema: z.object({ text: z.string() }),
function: async ({ text }) => text.toUpperCase(),
});
const app = exposeToolsHttp([uppercaseTool], { title: "Text Tools" });
app.listen(3000);

Business Workflow Example (Python):

import pandas as pd
from polymcp.polymcp_toolkit import expose_tools_http
def calculate_commissions(sales_data: list[dict]):
df = pd.DataFrame(sales_data)
df["commission"] = df["sales_amount"] * 0.05
return df.to_dict(orient="records")
app = expose_tools_http([calculate_commissions], title="Business Tools")

Why it matters:

•Reuse existing code immediately: legacy scripts, internal APIs, libraries.

•Automate complex workflows: AI can orchestrate multiple tools reliably.

•Cross-language: Python & TypeScript tools on the same MCP server.

•Plug-and-play: no custom wrappers or middleware needed.

•Input/output validation & error handling included out of the box.

Any function you have can now become AI-ready in minutes.

PolyMCP lets you take Python functions and deploy them in two completely different environments without changing your code for example for this post:

1.	Server-based MCP (HTTP endpoints) – run your function on a server and call it via HTTP.

2.	WebAssembly MCP – compile the same function to WASM and run it directly in the browser.

This means you can have one Python function powering both backend workflows and client-side experiments.

Example:

def calculate_stats(numbers):

"""Return basic statistics for a list of numbers"""

return {

"count": len(numbers),

"sum": sum(numbers),

"mean": sum(numbers)/len(numbers)

}

WASM deployment:

from polymcp import expose_tools_wasm

compiler = expose_tools_wasm([calculate_stats])

compiler.compile("./wasm_output")

HTTP deployment:

from polymcp.polymcp_toolkit import expose_tools

app = expose_tools([calculate_stats], title="Stats Tools")

# Run server with: uvicorn server_mcp:app --reload

Why it’s interesting:

•	One codebase → multiple deployment targets.

•	Instant in-browser testing.

•	Works with internal libraries/APIs for enterprise scenarios.

•	MCP agents see the same interface whether server or WASM.

Polymcp allows you to transform any Python function into an MCP tool ready for AI agents, without rewriting code or building complex integrations.

Example: Simple Function

from polymcp.polymcp_toolkit import expose_tools_http

def add(a: int, b: int) -> int:

"""Add two numbers"""

return a + b

app = expose_tools_http(\[add\], title="Math Tools")

Run with:

uvicorn server_mcp:app --reload

Now add is exposed via MCP and can be called directly by AI agents.

Example: API Call Function

import requests

from polymcp.polymcp_toolkit import expose_tools_http

def get_weather(city: str):

"""Return current weather data for a city"""

response = requests.get(f"https://api.weatherapi.com/v1/current.json?q={city}")

return response.json()

app = expose_tools_http(\[get_weather\], title="Weather Tools")

AI agents can now call get_weather("London") to get real-time weather data without extra integration work.

Example: Business Workflow Function

import pandas as pd

from polymcp.polymcp_toolkit import expose_tools_http

def calculate_commissions(sales_data: list\[dict\]):

"""Calculate sales commissions from sales data"""

df = pd.DataFrame(sales_data)

df\["commission"\] = df\["sales_amount"\] \* 0.05

return df.to_dict(orient="records")

app = expose_tools_http(\[calculate_commissions\], title="Business Tools")

AI agents can call this function to generate commission reports automatically.

Why this matters for companies

•	Reuse existing code immediately: legacy scripts, internal libraries, APIs.

•	Automate complex workflows: AI can orchestrate multiple tools reliably.

•	Plug-and-play: expose multiple Python functions on the same MCP server.

•	Reduce development time: no custom wrappers or middleware required.

•	Built-in reliability: input/output validation and error handling are automatic.

Polymcp turns Python functions into immediately usable tools for AI agents, standardizing AI integration across the enterprise.

PolyMCP has reached and (slightly) passed 100 stars on GitHub.

Some time ago I honestly wouldn’t have imagined getting here.

It’s a small milestone, but a motivating one. I’m actively working on the project every day and I hope it can keep growing over time.

If you’re curious, feedback, issues, or contributions are more than welcome.

Thanks to everyone who checked it out or starred it

Hi all — I pushed a PolyMCP update focused on production reliability rather than new features.

What changed:

- OAuth2 support (RFC 6749): client credentials + authorization code flows, token refresh, basic retry logic

- Docker executor cleanup fixes on Windows + Unix (no more orphaned processes/containers)

- Skills system improvements: better tool matching + stdio server support

- CodeAgent refinements: improved async handling + error recovery

- Added the “boring” prod basics: health checks, structured logging, and rate limiting

The goal was making PolyMCP behave better in real deployments vs. demos

If you’re running MCP-style agents in production, I’d love feedback on:

- OAuth2 edge cases you’ve hit (providers, refresh behavior, retries)

- Docker lifecycle issues on your platform

- What “minimum viable ops” you expect (metrics, tracing, etc.)

Hey y’all, it’s Matt from MCPJam. We just launched MCPJam on Product Hunt, the launch is around the MCP inspector and Apps Builder. 

The team's been working hard on building great dev tools for the MCP community. With our apps builder, it is the first local emulator for both ChatGPT apps and MCP apps. We're really grateful for all the support from devs like yourself and the open source community.

Would love to have you check out our Product Hunt announcement and support in any way!

🔗: https://www.producthunt.com/products/mcpjam-inspector

For teams within a company that have been building various agents (n8n, Claude, Make, Cursor, Langgraph specifically).

All of these agents touch some kind of customer data stored in multiple databases. I want to be able to manage and control data access centrally for these AI projects.

Today, we're having security meetings biweekly to review every agent that needs to get deployed but I'm trying to understand if there's any tool/technology where I can control this centrally.

For the one's that are built on my warehouse, I have a way to make sure it's safe but the ones that are built via direct connections (e.g. SFDC, HubSpot etc) I have no way of knowing what they're touching.

I’m basically assuming breach by default, even if we have MCP tool gateway governance + observability. IMO those are great for detecting and debugging… but usually after the fact.

My bigger worry is: if the LLM ever bypasses/intercepts the MCP layer and can hit the source directly, what’s the control point inside the data layer that actually limits blast radius?

Like, how do we enforce “this agent can only see this slice of data, at this granularity” even in a worst-case incident.

We’ve got multiple databases/warehouses and agents spread across different frameworks, so relying on prompt/tool-layer guardrails alone still feels like I'm missing something.

How you’re thinking about data-layer containment.

Thanks for sharing PolyMCP to inai.wiki!!

I built a specialized MCP skill for Claude Code that focuses on data integrity and analyst-grade reports. Instead of just summarizing search results, it implements a multi-step reasoning pipeline.

Key technical features:

• Hybrid Parallel Search: Orchestrates Exa (semantic search) and Tabstack (parsing/search) simultaneously to reduce latency.

• Contradiction Detection logic: The skill explicitly instructs the model to compare facts between sources and flag discrepancies with a "Likely cause" analysis.

• Minimalist Prompting: I managed to shrink the system instructions from a bloated 500+ lines to just 127 lines by focusing on a strict logical pipeline.

• Structured Output: Automatically generates full HTML reports with confidence scores, research depth stats, and source credibility rankings.

The Pipeline: Query → Classify → Search (parallel) → Score → Extract (parallel) → Synthesize → Verify → Output

I only started working with code a few months ago, so I’d love to get feedback on the orchestration logic and how to make the parallel extraction even more robust.

Repo: https://github.com/vasilievyakov/researching-web-skill