DEV Community: Developer Harsh

9 Ways to Cut Token Consumption in Claude Code

Developer Harsh — Sat, 30 May 2026 11:40:56 +0000

After using Claude Code for serious coding work, the biggest lesson is simple: token consumption is not mainly a pricing issue. It is a workflow problem.

When my Claude Code session gets messy, performance drops. It starts rereading irrelevant files, remembering failed attempts, carrying old logs, and wasting context on things that no longer matter.

So my workflow is built around one principle:

Keep Claude's active context small, clean, and useful.

These are the 9 best ways to reduce token consumption in Claude Code that I use every day and can probably help you too.

tldr;

Don't send raw logs or full test results. Use filters and simple command wrappers to show only what matters: the error, the stack trace, the key details.
Sonnet handles most coding work fine and costs less. Use Opus for the really hard problems. For helper tasks and exploration, use Haiku.
Don't run expensive models on simple edits, and turn off extended thinking when you don't need deep reasoning.
Use /compact during a cleanup task while keeping what's important.
Use /clear with a handoff file when switching to something completely different. This doesn’t let old failed attempts pile up in context memory.
Only put instructions that Claude needs most of the time (how to run tests, build commands, folder structure, main rules). Keep everything else in separate skill files and only load them when you actually need them, saving your tokens.
Use Composio MCP to manage 1000+ tools as a single system instead of juggling 30+ active servers. When tasks are simple enough to use shell commands, use the composio CLI.

Filter the tool output before Claude sees it Raw logs are garbage for context. Claude does not need a 10,000-line test output. Instead, it needs the failing test, the stack trace, the expected vs. received values, and maybe the changed files.

So I avoid this:

npm test

And use filtered commands:

npm test2>&1 |grep-A5-E"FAIL|ERROR|Error|Expected|Received" | head-100

In my ideal setup, I create small wrappers like below and use them when needed:

cc-test
cc-lint
cc-typecheck
cc-log
cc-ci

Bottom line here is, I let Claude consume summaries, not terminal noise.

This one change saves the most tokens because it prevents context pollution before it even starts.

Match the model to the task Not every task needs the same horsepower, and running Opus on everything is one of the most expensive habits in Claude Code. Most coding work does not need Opus. Sonnet handles it at a fraction of the cost.

My setup:

/model sonnet   → default for most coding work
/model opus     → complex architecture, deep reasoning, tricky bugs
/model haiku    → repetitive tasks, boilerplate, quick lookups

I switch to Opus when I genuinely need deeper reasoning, and switch back as soon as the hard part is done.

For subagents specifically, I set:

CLAUDE_CODE_SUBAGENT_MODEL=haiku

This means exploration agents, log inspectors, and doc-lookup agents all run on Haiku. The main thread stays on Sonnet.

Extended thinking is another hidden cost - it burns output tokens for internal reasoning. For simple edits, I disable it:

MAX_THINKING_TOKENS=0      → trivial tasks
MAX_THINKING_TOKENS=10000  → architectural reasoning

In fact, this approach is so effective that it rarely lets my context memory fill up before it resets the 5-hour limit. Basically unlimited usage!

Bottom line: Using Opus for everything is like running every database query on your most expensive production server. Match the model to the work.

3. Don't let one session run forever with `/clear` + `/compact` + `handoffs`

After enough turns, the context fills with old attempts, wrong theories, stale file reads, and outdated decisions. Even if Claude still remembers everything, much of that memory is now toxic.

So I use /clear, but with a different workflow. I create a handoff.md file, include all the relevant details required, like goal, changed file, decisions made, and so on

Here is how you can do it too.

Before clearing:
Ask Claude to write .claude/session-handoff.md

Include:
- current goal
- changed files
- decisions made
- failing tests
- root cause
- next step

Then I run:

/clear

And restart with:

Read .claude/session-handoff.md and continue.

This gives me the best of both worlds: fresh context without lost progress.

For mid-task cleanup without a full reset, I use /compact instead. But I never run it blindly. Before compacting, I tell Claude exactly what to preserve:

/compact Preserve: optimistic locking for user updates, no schema changes this session.

Then:

/compact

This shapes what the summary will capture. In short, critical decisions gets added to context, while removing the noise.

The difference (a must-know):

/compact: summarize and continue, for tasks that require a lighter context.
/clear: full reset with handoff file, for tasks that require switching or starting fresh.

Bottom line: Don't treat /clear as a reset button. Treat it as context garbage collection. Use /compact for garbage collection mid-flight with instructions.

4. Keep `CLAUDE.md` minimal

Most people overload CLAUDE.md. They add architecture notes, deployment steps, PR rules, debugging checklists, style guides, testing philosophy, and random project history.

That feels organized, but it silently burns context every session.

My rule:

If Claude does not need it in 80% of sessions, it does not belong in CLAUDE.md.

My CLAUDE.md only includes:

- package manager
- test command
- build command
- repo layout
- core architecture constraints
- forbidden patterns
- naming conventions

Everything else goes into skills or separate docs folder.

Example:

.claude/skills/db-migration/SKILL.md
.claude/skills/pr-review/SKILL.md
.claude/skills/prod-debugging/SKILL.md

Bottom Line: Keep the base context light. loads the long workflow only when it's needed, keeping context quality intact.

5. Use plan mode before touching any code

Most context waste happens because Claude jumps straight into implementation without a clear plan.

It reads files speculatively, tries an approach, backtracks, and reads more files. By the time it reaches a working solution, the session is already polluted with failed attempts.

Plan mode separates thinking from doing by restricting access to the write-and-modify tool.

I press Shift+Tab twice before doing anything non-trivial

Shift+Tab → plan mode on

In plan mode, Claude reads files and reasons through the problem without making any changes. I let it map dependencies and surface unknowns.

Then I press Ctrl+G to open and edit the plan directly before Claude writes a single line of code.

Bad prompt (no plan):

Add Google OAuth to the login system.

Better workflow:

[plan mode on]
I want to add Google OAuth. What files need to change?
What is the session flow? Create a plan.

[review plan, edit if needed]

[plan mode off]
Now implement from the plan.

Bottom line: Claude solving the right problem the first time is always cheaper than rework. Let it plan, verify, and then execute.

6. Use bounded subagents for noisy exploration

Subagents are useful, but only when tightly controlled, as they tend to wander off.

I don't prompt:

Investigate the repo.

I prompt:

Inspect only src/auth and tests/auth.
Return max 15 bullets.
Include exact files.
No implementation.
No broad repo scan.

In general, I use Claude subagents for noisy work, such as log analysis, test failure inspection, dependency search, doc lookup, and blast radius analysis.

This multi-agent collaboration yields a cleaner workflow than a single-agent approach.

Bottom Line: The main Claude session should not carry all the exploration. It should only receive the compressed result from each agent.

7. Force surgical repo navigation

I don't ask Claude to "understand the codebase and explain it to me."

That usually causes broad scanning of wrong files, leading to unnecessary context usage, not to mention agents creating docs in the native repo (recent times)

Instead, I create a docs/repo_map.md with:

- main entrypoints
- key modules
- test commands
- auth/data/payment flows
- generated folders to avoid
- files Claude should read first

and then prompt accordingly. Here is an example of what I mean.

Bad prompt:

Understand the auth system and fix the bug.

Better prompt:

Find the login entrypoint. Read only the files needed to explain token validation. Do not scan unrelated directories.

This saves a lot of tokens because Claude starts from a map instead of wandering through the repo and figuring the repo out.

Bottom line: Repo Maps leads to fewer incorrect file reads, reducing context usage.

8. Lean on skills and plugins for progressive disclosure

Pulling stuff out of CLAUDE.md only helps if the place you move it to isn't also loaded every session. That is exactly what skills are for.

A skill is just a folder with a SKILL.md (a short name + description, then instructions, plus any reference files or scripts). The win is how it loads: at session start Claude only sees the name and description of each Claude skill, roughly 30 to 100 tokens each.

The full SKILL.md body loads only when Claude decides the skill is relevant, and any bundled reference files or scripts load only if they're actually needed.

So I can keep deep workflows around without paying for them upfront:

.claude/skills/db-migration/SKILL.md
.claude/skills/pr-review/SKILL.md
.claude/skills/prod-debugging/SKILL.md

Eight of these sitting in the project might cost a few hundred tokens at startup instead of dumping thousands of lines into context before any work begins.

The description is doing all the heavy lifting here, so I write it specific. "Helps with documents" never triggers. "Use when filling PDF forms and extracting table data" does.

Plugins are the next layer up. A plugin bundles skills, slash commands, subagents, hooks, and MCP servers into one installable unit, and you enable or disable the whole bundle on demand:

/plugin marketplace add <marketplace>
/plugin add <plugin>

The point is the same as everything else in this post: keep dormant capability out of the active context. Install the plugin when a project needs it, disable it when it doesn't, and you never carry tooling you aren't using.

Bad setup:

Everything stuffed into CLAUDE.md so it's "always available."

Better setup:

Tiny CLAUDE.md. Long workflows as skills with sharp descriptions. Capability sets as plugins you toggle per project.

9. Using Composio MCP and CLI

One of the top bottlenecks for me with the introduction of MCP was managing 30+ MCP integrations. Use fewer MCP servers, and the work won't be done. Use more, and it will add to the context memory.

Composio solved this for me by offering a universal MCP server that plugs into any MCP-supported agents and lets it connect to 1000+ services and tools, with on-demand tool loading, remote workbench for composing tools, and bash tool for handling edge cases with scripting.

Here is a brief breakdown of token savings with Composio MCP and without it for tasks that use tools such as Linear, GitHub, Sentry, Supabase, and Context7.

Without Composio MCP

With Composio MCP

As you can see, Composio used fewer tokens than the raw approach. It uses only seven meta tools and gets’ you the best bang for token used.

When I need even more reduction on top of that, I use the Composio CLI directly.

LLMs understand and parse shell commands better than tool schemas, they can be combined with multiple commands (composable), and has less to and from between servers and the LLM. It’s faster.

My rule: I start with Composio MCP to consolidate integrations, then move to CLI when the task is simple enough for a shell command.

Bottom line: Active MCP is added as a context tax that compounds across every chat. Every active tool adds overhead to the schema, description, and result. So use fewer, smarter integrations, not more.

My actual Claude Code workflow

If I were setting this up for daily development, my stack would look like this (in no particular order):

Start with tiny CLAUDE.md
Keep long workflows in skills
Use repo-map.md for navigation
Use cc-test / cc-log / cc-diff wrappers
Use Composio MCP to consolidate integrations, and CLI when a shell command will do
Use subagents for exploration, the Haiku model for agents
Write handoff.md before clearing context
Enter plan mode before any non-trivial implementation
/compact with explicit preservation instructions at task boundaries
/clear aggressively between unrelated tasks
Switch to Opus only for deep reasoning, back to Sonnet after
Keep the main thread clean

The real mindset shift for you is this:

Claude Code works best when you treat it like a powerful engineer with limited working memory.

Don't dump everything on it. Don't make it read garbage. Don't let old context pile up. Give it the right files, the right errors, the right constraints, and a clean session.

That is where token savings actually come from. Perform better harness engineering.

I Took Cursor Agents Out of the IDE and It Got Weirdly Powerful 🤯

Developer Harsh — Tue, 19 May 2026 10:05:31 +0000

Cursor recently released their cursor agents SDK to the public, and it's quietly powering many teams to:

invoke agents directly from CI/CD pipelines,
create automations for end-to-end workflows,
and embedding agents into core products.

Basically, the SDK lets developers deploy agents without overthinking building and maintaining the entire agent stack

in this blog I give a glimpse of what is possible with the cursor agents SDK and how to overcome the restrictions of limited tool access.

Let's start with a brief overview of cursor agents.

A Primer On Cursor Agents SDK

Building an agent from scratch is a massive headache. Cursor SDK skips the
plumbing.

Before the SDK, Cursor was strictly an interactive IDE, but its newly released SDK turns that
agentic power into headless infrastructure.

It uses the same harness that powers the desktop app, meaning you get IDE-grade code generation programmatically.

Harness: context engine, workspace management, and routing

In fact, the cursor harness matters more than the model. Endor Labs benched
GPT-5.5 natively at 61.5% functional correctness. Then, dropping the same model into Cursor's harness, it scored 87.2%.

Cursor spent years tuning the context management and tool dispatch; the SDK hands you that refined engine.

Here is the spec list for those who care:

Spec / Feature	Technical Detail
The Harness	Built-in codebase indexing, semantic search, & instant grep.
Execution	Cloud (sandboxed VMs with durable state), Self-Hosted, Local.
Models	Agnostic. Uses `composer-2/composer-3` (default), Claude, or OpenAI.
Integrations	Deep MCP support, auto-loaded `.cursor/skills/`, & hooks.
Subagents	Main agent can spawn subagents with distinct prompts/models.

This means we have a perfect stack to build our agent. Let’s get started with the setup.

How to Set Up Cursor Agents SDK

You can install it using npm to get started, then use Cursor's native cursor SDK skill for guidance.

So open your terminal and type:

npm install @cursor/sdk

Output

Once done, install the cursor skill for guiding the cursor / Claude Code. In the same terminal, run:

npm add skills /cursor-sdk

But there is a catch: by default, the Cursor SDK agents ship with a few default tools + MCP support.

However, this means connecting to or configuring multiple MCP servers is such a hassle for a production-grade product.

So let's automate it with Composio as the orchestrator, connect and configure it once, and you get secure access to 1000+ tools with optimized tool calls and context.

Building a Production Agent With Composio MCP + Cursor Agent SDK

Why Composio?

Composio offers a single MCP server you can plug into with the Cursor SDK to access 1000+ apps instantly.

When you’re building an agent that requires interacting with external applications, let’s say a Sales agent with Gong, HubSpot, Salesforce connectors, etc., you’d spend weeks on partnerships and integrations. Composio completely removes this friction, so you build what matters

So, let’s explore one example of a GitHub agent that pulls the repository, analyzes it, creates a dev branch, performs automatic refactoring, pushes the code, and opens a PR for review - a simple but powerful use case.

Let's begin!

Setup Workspace

Head to the terminal and run the following commands

mkdir cursor-agent
cd cursor-agent
npm init -y
npm install typescript ts-node @types/node --save-dev
npx tsc --init

The command will create a new project named cursor_agent , switch to the folder, initialize a blank npm project (ensure package.json gets created), install typescript support for development, and initialize the typescript compiler and linter.

Since our repository is set up, let’s configure environment variables.

Set up Environment Variables

Add a .env file to keep secrets secure and add the following values:

CURSOR_API_KEY=your-cursor-api-key
COMPOSIO_API_KEY=your-composio-api-key

You can get the CURSOR_API_KEY by going to the Cursor integration page and creating a new API key.

For COMPOSIO_API_KEY , visit the Composio Dashboard (Platform), log in/sign up to the account, and head to the default project (or create one) → profile→ API KEY.

Click “Create One”, it creates one, copy and then paste it into .env . Make sure it starts with ak_ .

Time to write the code.

The Code

Now, create a new index.ts file and paste the following code.

// imports
import "dotenv/config";
import * as readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";
import type { SDKAgent } from "@cursor/sdk";
import {
  DEFAULT_USER_ID,
  disposeAllAgents,
  getComposioApiKey,
  getOrCreateRuntime,
  requireEnv,
} from "./runtime.ts";

// log tool calls to stdout
function logToolCall(
  name: string,
  args: unknown,
  status: "running" | "completed" | "error",
): void {
  if (status === "running") {
    console.log(`\n[tool: ${name}] ${JSON.stringify(args)}`);
  } else if (status === "completed") {
    console.log(`[tool: ${name}] done`);
  }
}

// stream assistant text and tool events - act as streaming handler
async function runAgentChatStreaming(agent: SDKAgent, message: string): Promise<void> {
  const run = await agent.send(message);

  process.stdout.write("\nagent > ");
  for await (const event of run.stream()) {
    if (event.type === "assistant") {
      for (const block of event.message.content) {
        if (block.type === "text") process.stdout.write(block.text);
      }
    } else if (event.type === "tool_call") {
      logToolCall(event.name, event.args, event.status);
    }
  }

  const result = await run.wait();
  if (result.status === "error") {
    throw new Error(`Agent run failed (${result.id})`);
  }
  process.stdout.write("\n\n");
}

// runs the chat loop, adds a readline interface and disposes agents on exit
async function main(): Promise<void> {
  requireEnv("CURSOR_API_KEY");
  getComposioApiKey();

  console.log("Setting up Composio session...");
  const runtime = await getOrCreateRuntime(DEFAULT_USER_ID);
  console.log(
    `Ready (user: ${runtime.userId}, session: ${runtime.sessionId}, tools: ${runtime.toolsCount}).`,
  );
  console.log("Type a message, or 'exit' to quit.\n");

  const rl = readline.createInterface({ input, output });

  try {
    while (true) {
      const userInput = (await rl.question("you > ")).trim();
      if (!userInput) continue;
      if (userInput === "exit" || userInput === "quit") break;

      await runAgentChatStreaming(runtime.agent, userInput);
    }
  } finally {
    rl.close();
    await disposeAllAgents();
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

Let's look at the code:

We start by loading dependencies from .env, readline, and shared helpers from runtime.ts (getOrCreateRuntime, API key checks, and cleanup)
For a sanity check, we validate CURSOR_API_KEY and COMPOSIO_API_KEY before the chat loop starts (Composio is also checked when runtime.ts loads).
Next, we create a Composio session for the default user and spin up a Cursor agent on composer-2 with the Composio MCP server for tools (handled in runtime.ts).
We keep the same agent in the loop for every message, so tools and sessions stay wired throughout the CLI session.
We run a terminal chat loop with readline: read input → send to agent → stream assistant text and tool status → repeat until exit or quit.
While streaming, we log tool calls on running and completed, and throw if the agent run ends in error.
On exit, we close readline, dispose of agents via runtime.ts, and log any failure from main() before exiting with code 1.

If you encounter an issue, refer to the codebase in the project's GitHub repo. Feel free to clone it, tweak it to your liking, or use it as it is.

And that's it, all set, time to run the agent!

Run the agent

To run the agent in the terminal and at the project root, type:

npx ts-node index.ts

and an interactive chat opens up where you can prompt it step by step / direct it to do the entire task at once. Here is a demo of me using it in chat mode (step by step)

As you can see, the cursor agent acts as the brain, calling the Composio GitHub tools to clone the repo, check for changes, create a dev branch, refactor the code, commit to the dev branch, and finally open a PR.

Usually, this takes many human hours, but with a cursor-agent, it takes only 5 minutes.

Also, with the new update, you need to add a GitHub token to use GitHub with the cursor/agent. Using Composio fixes this need as well.

Note: For simplicity I have used terminal , but you can add a ui layer on top of the agent.

With this, we have reached the end of the article. Here is my closing note.

Final Thoughts

In this article, we learned how to use the Cursor SDK and Composio MCP to build a GitHub chatbot while keeping it optimized for asynchronous operations and following best practices, such as masking sensitive variables.

But this is just the tip of the iceberg with what's possible with the cursor agent SDK. Feel free to experiment and build your own assistant/chatbot. You can explore more in the cursor-cookbook.

At the end of the day, building agents / multi-agent systems is not hard; planning and orchestrating them to work efficiently, collaboratively, and securely is. In fact, it's the next valuable skill in 2026.

So what are you waiting for? Get started with Cursor Agents while Composio MCP handles the tooling layer.

Building Streamable HTTP MCP Servers from Scratch using FastMCP in 2026

Developer Harsh — Mon, 18 May 2026 14:50:04 +0000

If you've spent any time wiring up tools for an AI agent, you know the pain: every model vendor has its own function-calling format, every integration is bespoke glue code, and every model upgrade breaks something downstream.

MCP changes this by providing a shared interface for tools, data sources, and AI clients. Instead of rebuilding integrations for every model or app, you expose capabilities once through an MCP server and let compatible clients connect to them.

Anthropic released the Model Context Protocol in November 2024, and by spring 2025, OpenAI, Microsoft, and Google had adopted it. It has quickly become the de facto standard for connecting AI systems to external tools and data. That makes MCP worth learning now.

This guide teaches you how to build an MCP server from scratch, expose it over two transports: stdio and streamable HTTP, connect it to Claude Desktop and Cursor. and provide you with a production checklist for hardening the production MCP servers before shipping them. The full code is available in the companion repo at the end

tl; dr

What is MCP
MCP Components in Nutshell
Build a Local MCP server (tools, resources, and prompts)
Connect to Hosted MCP Server (HTTP Streamable)
MCP Server Advance Use Case
Deployment Notes for Production MCP Servers
Conclusion
Frequently Asked Questions

Let's Begin!

What is MCP

An MCP server is a JSON-RPC 2.0 process that exposes three primitives to any compliant MCP client over stdio or streamable HTTP. Those primitives are tools (functions the model can call), resources (data the model can read), and prompts (reusable templates). That's the whole protocol.

Everything else is an implementation detail as given in the comparison table.

Feature	Model Context Protocol (MCP)	Traditional API (REST / GraphQL / gRPC)
Primary purpose	Give LLM-based agents a single way to fetch context and invoke side-effecting tools.	General machine-to-machine data exchange & business logic.
Integration effort	Once an agent speaks MCP, it can talk to any compliant server; only one SDK/wire-spec to learn.	Each API exposes its own spec/SDK; you integrate them one by one.
Interaction model	Stateful sessions + bidirectional messaging; supports long-running tasks and mid-job progress callbacks.	Stateless request/response; usually unidirectional.
Streaming support	Standardised via “Streamable HTTP” (SSE/WebSocket).	Not part of the REST spec; developers bolt on WebSockets/SSE ad hoc.
Extensibility (adding new capabilities)	The server can add new tools/resources without breaking clients; the agent discovers them at runtime.	Breaking changes need versioning, or clients must update to use new endpoints/types.
Standardisation/wire format	One JSON-Schema-driven spec for inputs & outputs, plus defined transports.	Multiple styles (REST, GraphQL, gRPC) with differing auth headers, error shapes, and media types.
Maturity & tooling	Rapidly growing, but still early; dozens of open-source servers and early commercial support.	Decades of best-practice guides, gateways, SDKs, APM, and monitoring.
Performance path length	Extra hop (agent → MCP → underlying API) adds a bit of latency; streaming mitigates waiting for large payloads.	Direct call; generally lower overhead for high-QPS, deterministic workloads.
Typical sweet-spot use-cases	Autonomous agents chaining multiple tools, dynamic workflows, and user-in-the-loop	CRUD data services, stable integrations, high-throughput micro-services.

If you want a deeper conceptual primer, check out the Model Context Protocol explainer, which covers the architecture in detail. For primer, here is how this all works!

MCP Components in Nutshell

The Architecture

The MCP architecture consists of several key components that work together to enable seamless integration:

MCP Hosts: Applications that want to use tools or data through MCP. Examples include Claude Desktop, Cursor, or any AI app that supports MCP.
MCP Clients: Client instances created by the host. Each client maintains a dedicated one-to-one connection with a single MCP server.
MCP Servers: Lightweight programs that expose tools, resources, and prompts through the MCP protocol.
Local Data Sources: Files, databases, codebases, or local services that an MCP server can access on the user’s machine.
Remote Services: External APIs or cloud services that an MCP server can call, such as Google Sheets, GitHub, Slack, or Postgres hosted in the cloud.

At a high level, the host does not talk directly to your database, file system, or API. Instead, it talks to an MCP client, which talks to an MCP server, which then talks to the actual data source or service.

This simple diagram might help you understand the flow better:

The key point is that MCP servers serve as the integration layer. They hide the messy parts of authentication, API calls, file access, and business logic behind a clean protocol interface.

This separation of concerns makes MCP servers modular and maintainable. The AI app does not need to know how Google Sheets, GitHub, or a local database works. It only needs to know how to call the MCP server.

So how does this all connect?

How The Components Work Together

Let's understand this with a practical example:

Say you're using Claude Code (an MCP host) to manage your project's budget. You want to update a budget report in Google Sheets and send a summary of the changes to your team via Slack.

Claude Code (MCP host) initiates a request to the MCP client to update the budget report in Google Sheets and send a Slack notification.
The MCP client connects to two MCP servers: one for Google Sheets and one for Slack.
The Google Sheets MCP server calls the Google Sheets API (remote service) to update the budget report.
The Slack MCP server interacts with the Slack API (remote service) to send a notification.
MCP servers send responses back to the MCP client.
The MCP client forwards these responses to Cursor, which displays the result to the user.

This process happens seamlessly, allowing Cursor to integrate with multiple services through a standardized interface.

That's the working in a nutshell. From here on, we will focus on building.

Build Local Stremable HTTP MCP Servers

We'll build something you'd actually deploy: a GitHub issue search server that lets your AI assistant search issues, fetch issue details, and pull recent pull requests from any repository. [subject to change]

We will follow a series of steps to make sure things go smoothly. This is also industry standard, so it's best to follow along.

Prequires

Before anything else, ensure you complete the prerequisites, as they will be the foundation for any MCP implementation we do.

You'll need:

Python 3.10+
Node.js 18+ for TypeScript (if you choose to build with TypeScript)
Claude Desktop or Cursor for testing

A common question users often ask: when should you pick Python vs. TypeScript? Here is an honest review:

Python with FastMCP is faster for prototyping and works well for stdio servers.
TypeScript shines for HTTP servers deployed to Cloudflare Workers, Vercel Edge, or any Node-based stack due to its type safety.

In case you are wondering, Composio is the ultimate integration platform, empowering developers to seamlessly connect AI agents with external tools, servers, and APIs with just a single line of code.

With the fully managed MCP Servers, developers can rapidly build powerful AI applications without the hassle of managing complex integrations.

In a nutshell: Composio handles the infrastructure so developers can focus on innovation.

Next, let's set up the working environment.

Work Environment Setup

We start by creating a project directory.

Navigate to your working folder and create a folder named MCP, or u can use the terminal command:

mkdir mcp_servers
cd mcp_servers

Next, create a virtual environment using:

python3 -m venv .venv

Now activate the environment with:

# Windows:
.venv\Scripts\activate

# Linux/Mac:
source .venv/bin/activate

Ensure you see (.venv) in Front of the terminal cwd path.

Finally, install the FastMCP package

pip install FastMCP

Writing Server Code

Server code is where the entire MCP server logic lives. Create a new server.py file and inside it paste the code below:

# server.py

# imports
import base64
import os
import uuid

from typing import List
from fastmcp import FastMCP

mcp = FastMCP("Utility MCP Server")

# generate password utility
@mcp.tool()
def generate_password() -> str:

    """
    Generate a pseudo-random password for development use.

    This function creates a password by encoding a UUID4 string in base64
    and then reversing the resulting string. It's intended for use in
    development or testing environments where cryptographic security is not
    critical.

    Returns:
        str: A reversed base64-encoded UUID4 string, typically around 48 characters.
        May include alphanumeric characters, '+', '/', and '=' padding.

    Security Notes:
        - Uses the string form of UUID4 (not raw bytes), so effective entropy is lower (~190 bits of input chars)
        - Suitable for temporary or development credentials.
        - NOT recommended for production use.
        - For higher security, consider using secrets.token_urlsafe().

    Example:
        >>> generate_password()
        '==dGM0ZTcwLTI0ZTUtNDJlZC05Y2I1LTk3OGJjODAxMDAwNw=='
    """

    uuid_string = str(uuid.uuid4()).encode()
    base64_encoded = base64.b64encode(uuid_string).decode()
    return base64_encoded [::-1]

# list all the files in the directory
@mcp.tool()
def list_files(directory: str = ".") -> List[str]:
    """
    List all files and directories in a specified path.

    This tool allows the AI to explore the file system by returning a list 
    of names of the entries in the directory given by path.

    Args:
        directory (str): The path to the directory to list. Defaults to the 
        current working directory (".").

    Returns:
        List[str]: A list of filenames and directory names. If an error 
        occurs (e.g., directory not found), returns a list containing 
        the error message.
    """
    try:
        return os.listdir(directory)
    except Exception as e:
        return [f"Error: {str(e)}"]


# read the given file
@mcp.tool()
def read_file(filename: str) -> str:
    """
    Read and return the full text content of a file.

    This tool enables the AI to analyze the contents of specific text files 
    within the accessible file system.

    Args:
        filename (str): The path to the file that needs to be read.

    Returns:
        str: The complete string content of the file encoded in UTF-8. 
        If the file cannot be read, returns an error message starting 
        with "Error reading file:".
    """
    try:
        with open(filename, 'r', encoding='utf-8') as file:
            return file.read()
    except Exception as e:
        return f"Error reading file: {str(e)}"

# system info (resource)
@mcp.resource("data://sys-info")
def get_system_info() -> str:
    """
    Get a comprehensive system snapshot including time, hardware specs, 
    and real-time health metrics.
    """
    import platform
    import psutil
    import subprocess
    from datetime import datetime

    now = datetime.now()
    timestamp = now.strftime("%Y-%m-%d %H:%M:%S")
    day_name = now.strftime("%A")


    boot_time = datetime.fromtimestamp(psutil.boot_time())
    uptime = str(now - boot_time).split('.')[0]

    sys_type = platform.system()
    machine = platform.machine()
    cpu_count = psutil.cpu_count(logical=False)
    try:
        gpu_info = subprocess.check_output(
            ["nvidia-smi", "--query-gpu=gpu_name", "--format=csv,noheader"], 
            encoding="utf-8"
        ).strip()
    except Exception:
        gpu_info = "N/A (NVIDIA-SMI not found)"

    cpu_usage = psutil.cpu_percent(interval=None)
    memory = psutil.virtual_memory()
    disk = psutil.disk_usage('C:\\')

    return f"""
             --- Hardware Specs ---
            OS:        {sys_type} ({machine})
            CPU:       {cpu_count} Physical Cores
            GPU:       {gpu_info}

            --- Temporal Context ---
            Date/Time: {timestamp}
            Day:       {day_name}
            Uptime:    {uptime}

            --- Resource Utilization ---
            CPU Load:  {cpu_usage}%
            RAM Usage: {memory.percent}% ({memory.used // (1024**2)}MB / {memory.total // (1024**2)}MB)
            Disk (C:): {disk.percent}% Used ({disk.free // (1024**3)}GB Free)
            """

# general prompt
@mcp.prompt()
def helper_prompt(task: str, context: str = "") -> str:
    """General purpose prompt for any task with optional context."""
    base_prompt = f"""
Task: {task}

Please approach this systematically:
1. Break down the problem
2. Consider multiple solutions
3. Explain your reasoning
4. Provide clear, actionable steps
"""

    if context:
        base_prompt += f"\n\nAdditional context: {context}"

    return base_prompt

# api-design rules prompt
@mcp.prompt()
def api_endpoint_design_prompt(endpoint_name: str, purpose: str) -> str:
    """Specific prompt for designing RESTful API endpoints."""
    return f"""
Design a RESTful API endpoint: {endpoint_name}
Purpose: {purpose}

Please provide:
1. HTTP method and URL pattern
2. Request/response schemas with examples
3. Status codes and error handling
4. Authentication requirements
5. Rate limiting considerations
6. OpenAPI/Swagger documentation snippet

Follow REST conventions and include proper validation.
Use JSON for data exchange and meaningful HTTP status codes.
"""

# Run MCP server
# if __name__ == "__main__":
    # mcp.run()

# Run stremable http MCP Server (can be deployed / hosted)
if __name__ == "__main__":
   mcp.run(transport="streamable-http", host="0.0.0.0", port=8000)

Key points from the code:

mcp : It's the Fast MCP object named as provided. Important to initialize at the start.
@mcp.tool() : Decorator wraps the entire function underneath and exposes it as a tool to the MCP client. Docstrings are very important; a good docstring leads to fewer model failures. Includes generate_password , list_files, read_filetools.
@mcp.resource("data://sys-info") : Decorator wraps the entire function and exposes it as a resource file that the client can use to fetch data. The path to the created resource is defined in () . Includes get_system_info resource
@mcp.prompt() : Decorator wraps the entire function and exposes it to the client as a prompt builder, useful when the task requires a specific use-case prompt. Docstrings are important here. Includes helper_prompt , api_endpoint_design_prompt
mcp.run(transport="streamable-http", host="0.0.0.0", port=8000) : Runs the MCP server.in a streamable HTTP mode. For stdio MCP server, use mcp.run()

Overall, we are wrapping different functions and exposing them to the client as the MCP tool, resources, and server.

However, to use it with the client, additional config is required, so let's set that up. I am using a cursor for the demo.

Head to the Cursor and create a new folder .cursor , inside it creates a new file mcp.json (the config file) and paste the following setup.


{
    "mcpServers": {
        "utility-server": {
            "url": "http://localhost:8000/mcp"
        }
    }
}

In case you have used mcp.run() then you will see the below configuration

{
    "mcpServers": {
        "utility_server": {
            "type": "stdio",
            "command": "your-python-exe-path",
            "args": ["your file path"]
        }
    }
}

In general I use local stdio based servers and then when all test and specifications are met, I switch to Streamble HTTP approach.

Quick Tip: To verify this works is by pasting the command and args together; if they start the server, you are good to go; else, provide the full path. I usually go for path of .venv’s python.exe

Open Cursor Settings, then click Tools & MCPs. You will see your local MCP name. Click Enable,

To check, open the terminal, switch to the Output tab, select the MCP server, and check for the connected message.

Now we can test our MCP Server by opening the chat/agents window and invoking any of the defined tools via the prompt. I invoked the password-generator, as I often find myself asking Claude to "think of a 16-character password" (which is terrible).

Generate password + show mcp tool usage

Here is the output:

Saw that Ran command, it means the MCP server asked me for permission. I kept it that way, as you never want to let an agent touch your system files.

Note: If docstring is poor, the mcp client might fall back to cli approach, the easiest way to fix this is add a rule to only use mcp servers for the task. You will find a similar approach in the project github repo as well.

All this is great, but setting it up for testing a local MCP server is a hassle. Let's look at an easier approach, MCP Inspector.

Test with MCP Inspector

To test the MCP server's functionality, we will use the Fast MCP Inspector, a browser-based tool that connects to the server and lets us call tools directly, without an LLM layer.

Run MCP Inspector, with:

npx @modelcontextprotocol/inspector python server.py

You'll see a localhost URL. Open it in your browser, click Connect, and you should see your server respond.

Now you can run and test your tools, resources, prompts, and more right from the browser, quite handy for developers testing MCP servers' performance and understanding response schemas. Check out the MCP Inspector Guide to learn more.

Personally, I find it best for testing prompts’ responses. Here is the response it generated:

Local servers are great for simple use cases, but for most industry use cases, they don't provide the required infrastructure. Let's explore better use cases.

Connect to Hosted Streamable HTTP MCP Server

Having a local server is good, but not as great as the one used in production. Usually, these are hosted, secured by design, and optimized for multiple tool calls.

Usually, these are servers written by expert developers, integrated with the app's internal mechanisms, and intended to serve as connectors.

But here lies the issue: connecting to 30+ MCP servers for a single project is a pain. Composio solves this.

Let's look at how you can connect to the hosted Composio MCP server. You connect it once and use 1K+ tools directly, all secure, optimized tool calls.

Connect to Composio MCP Servers (Streamable HTTP )

Integrating with Composio MCP is incredibly simple and takes just 5 steps.

Visit the Composio MCP page. Ensure you are logged in, or else sign up

In the dashboard, head to the Install Section

Select Cursor from the list, and click on Install.

In the redirected page, click on "Install in Cursor".

You will be redirected to Cursor, and in the MCP server Page, click Install

Once installed, click on Needs Authentication, then Authorize at redirect, and done!

You can connect to apps in advance in the Connect Apps section; most of them use OAuth. (optional). If you don't, the agent will prompt you to connect at runtime.

To test the integration, open the Composer, establish a connection to the app, and ask it to perform actions.

But how did all this happen?

It turns out that if you go to your cursor MCP & Tools Page, select the ✏️ icon, and see the configuration as:

{
  "mcpServers": {
    "composio": {
        "type":"http",
      "url": "https://connect.composio.dev/mcp",
      "headers": {}
    }
  }
}

The http here means a streamable HTTP server. This allows the MCP server to operate as a normal web server (accessible via a URL) rather than as a local subprocess on your machine (for local MCP servers)

And interestingly, for any MCP to run in HTTP streamable mode, you have to replace:

if __name__ == "__main__":
    mcp.run()

if __name__ == "__main__":
    mcp.run(transport="streamable-http", host="0.0.0.0", port=8000)

And you are done, pretty handy, isn’t it?

Now, let's look at an advanced use case to see where Composio MCP helps.

Using HTTP Streamable MCP Servers for Advanced Use Case (Financial Agent)

Current financial institutions struggle with manual, time-intensive investment research that keeps analysts buried in data entry for weeks, delays critical decisions by days, lacks real-time risk visibility, creates compliance blind spots, and demands hiring more analysts just to manage portfolio volume - all while losing talent and clients

Let's see how the analyst can build financial agents and leverage Composio MCP to connect to 10-15 financial data sources (Yahoo Finance, SEC filings, Google Sheets, Bloomberg, etc.) and enrich their analysis by aggregating structured APIs, unstructured web scraping, and internal data warehouses.

The financial analyst agent will:

Aggregate financial data (Yahoo Finance, Google Sheets with company data, SEC filings via web scraping),
Run Claude analysis to generate investment thesis.
Create formatted reports in Google Docs,
Track portfolio changes (pull from Excel sheet),
and send Executive Summaries to stakeholders via email with embedded tables. (HTML format)

All done in parallel!

Web Scraping (composio & search api) + Google Sheets (composio) → Claude Analysis → Google Docs (composio) → Gmail (composio)

Prerequisites

Claude Code / Cursor / VS Code. I am going with Claude
Composio Account, login/signup

Assuming you have pre-requisites met, let's set up Composio on Claude.

Set up Composio MCP in Claude

To get started:

Visit the Composio MCP page. Ensure you are logged in, or else sign up
In the dashboard, head to the Install Section
Select Claude from the list, and click on Install.

On the next page, select the MCP tab, then copy the command & paste it into the shell/terminal.

claude mcp add --scope user --transport http composio https://connect.composio.dev/mcp

Ensure /mcp shows composio as an option. It might require authentication, so authenticate once

(Optional ) Once done, head to the Connect Apps page and click on Connect to connect Gmail, Google Drive, Google Sheets, and Google Docs. In case you ignore, agent will ask for these connections on runtime.

Perfect, we only need to configure the document in the workspace

Set up Workspace for Agent

We will use Google Drive as our workspace to make the file accessible from everywhere:

Head to drive, create a new folder named financial_data & from the URL, copy the folder ID.
Inside, add an Excel file in the format & fill the data as:
- Companies: List of all targeted companies with their analysis
- Portfolio Performance: How the portfolio is performing over time, all metrics for targeted companies
- Contact: List of all internal contacts: Portfolio Managers, Limited Partners, Investors, Board Managers, and more
- Report Archive: Past report filing (sec)
Then add a Google Doc template for an investment report.

Make sure to copy the ID / URL of both files

Easiest way is to use the template given in the GitHub Repo and let any AI Agent turn them in the above given format. Then copy paste that in newly created google sheet & google doc file.

Now is the time to run the agent.

Run Financial Analyst Agent

To run the agent, open Claude Code and paste the financial_agent_prompt. You will be prompted to fill in the details with the copied values from earlier, and add your email address:

GOOGLE_SHEETS_ID: [your value]
GOOGLE_DOC_TEMPLATE_ID: [your value]
GOOGLE_DRIVE_FOLDER_ID: [optional]
GMAIL_SENDER_ADDRESS: [your gmail]

Once done, the agent handles the rest. Here is a demo of what it looks like, in production.

The agent also works on multiple portfolio reports. I am testing it with six different portfolios; you can adjust the count as needed.

Same setup, but with multiple portfolio data. Make sure to copy each one's ID, and use the financial_agent_prompt_for_multiple portfolio for the job.

Note that, despite explicitly stating that Claude never created a subagent, this is because composio already has parallel execution enabled and, behind the scenes, uses subagents.

Hope this gave you an idea of how hosted MCP servers work, and tools like Composio MCP provide a universal tooling layer.

However, deploying a hosted MCP server for production is a different game. Let's look at a few rules to help ensure the servers don't break in real-world use.

Deployment Notes for Production MCP Servers

Though we didn't cover a hosted MCP server build, if you want to build your hosted MCP server (local + later deployed), follow the production checklist before you deploy & put an MCP server in front of real users:

Logging to stderr or files only, never stdout for stdio servers
Errors caught on every tool: return a clean error message, don't let exceptions kill the connection
Inputs validated: type hints (Python) or Zod (TypeScript) catch most issues; add explicit checks for things like SQL injection or path traversal if you're doing database/file operations
External API calls are rate-limited / Use Composio MCP: your tool runs whenever the LLM decides to call it, which can be a lot. Let Composio MCP handle it.
Secrets in environment variables, never hardcode in servers, never commit in production.
Tool descriptions for the LLM: Write specific, one-purpose per tool. Five small tools beat one giant tool. The approach we followed.
Schema versioning: when you change a tool's signature, bump your server's version so clients can adapt. Think API versioning.
Health check endpoint: for HTTP servers, expose /health for your load balancer. Provides transparency to users.
Auth on production HTTP servers: Use Bearer for internal, OAuth for public. But never both for the same for public/internal (private)

With this, we have come to the end of this comprehensive guide. Here is what matters the most.

Conclusion

As AI transforms software development, MCP will play an increasingly important role in creating seamless, integrated experiences.

Whether you're building custom MCP servers or leveraging pre-built solutions like stremable http servers like Composio MCP, the protocol enables powerful enhancements to AI capabilities through external tools and data sources.

In case you need a few ideas, check out how to build an MCP client that talks to your server, or move up the stack and build an MCP-powered agent that orchestrates multiple servers at once. Happy building.

I hope you had a great learning experience - happy building with Composio! 🚀

Top Marketing Skills For Claude Code, OpenClaw & Hermes

Developer Harsh — Fri, 24 Apr 2026 06:18:47 +0000

With tools like Claude Cowork and OpenClaw, the marketing and GTM stack is evolving fast. People are spinning up SEO pages, firing UGC videos, automating ads at an industrial scale. And GTM and marketing is going to blow up in next few months.

So, I have curated some great skills that community has built and some of them I personally use.

So I spent last week testing and collating everything. Here are the 10 marketing skills for Claude Code/ Cowork and OpenClaw that are actually worth using.

Quick Summary

GEO / AEO (AI Search Optimization) Skill - Audits and optimizes pages to get cited in AI search (ChatGPT, Perplexity, Google AI Overviews) with fixes, llms.txt, and schema.
SEO + GEO Full-Stack Skill - An end-to-end workflow that does keyword research, drafting, and optimization for both traditional SEO and AI discovery.
Paid Ads Audit Skill - Runs deep multi-platform checks to find wasted spend, diagnose performance issues, and generate new creative and copy variants.
Firecrawl Web Intelligence Skill - Gives agents live web scraping and crawling to extract clean markdown and structured data for competitive research.
Design Skill - Extracts design systems from UI references and outputs design tokens and specs to keep builds consistent and non-generic.
Remotion Video Skill - Turns a video brief into Remotion-ready React code so you can ship programmatic product videos reliably.
Marketing Page Generation (Frontend) Skill - Generates bold, conversion-focused landing pages with production-ready code instead of generic SaaS templates.
Content Ops Skill - Runs the editorial pipeline end-to-end: audit, briefs, drafting, repurposing, and distribution from one workflow.
Humanizer Skill - Removes AI-writing tells through multi-pass editing so posts sound opinionated, natural, and genuinely human.

For using all these skills effectively you’ll need access to data stored in multiple different applications.

For example, for full SEO data you’d need access to Google Search Console, Ahref, etc. And for scheduling posts for social medias you’d need to connect Claude or OpenClaw with Tiktok, Youtube, LinkedIn, Reddit, and Twitter.

For Ads and conversion pipeline monitoring yo’d need Google Ads, MetaAds, Posthog, Mixpanel, etc.

Check Out the full catalog.

Composio is the single place to get all these apps using a single MCP server and it’s super easy to set it up. Just log in to dashboard.composio.dev and click on the client app you want.

If you need some guides, here’s how you can do it in OpenClaw and Claude Cowork.

For starters, let’s schedule a week of launch posts for social media - one of the grueling pain point for any content team.

Pre-requires (authenticate):

once all done, let’s create a 7 days launch post. This uses Claude Code.

/to-be-added

Top 10 Marketing Skills

Here are the list of top 10 marketing skills, that can 10 your marketing. For each I have shared:

What each skills does,
Why use it.
Prompt templates you can follow,
The link to get you started

Let’s begin:)

1. GEO / AEO SKILL - AI SEARCH OPTIMIZATION

AEO has become quite popular now a day’s, but not many are good at handling it.

This skill optimizes the content to get cited by ChatGPT, Perplexity, Google AI Overviews, and Gemini. Furthermore, it scores citability, generates llms.txt, adds schema markup, and outputs a client-ready PDF audit report.

Usage

Run a full GEO audit on any URL → get citability score + prioritized fix list across 13 dimensions.
Generate an llms.txt file so AI crawlers understand the product site structure and index it correctly.
Optimizes existing blog posts for AI citation with E-E-A-T signals, entity clarity, and FAQ schema injection
Produce a branded PDF GEO report ready to send to a client or CMO, for contrast agencies charge $2K–$12K for this

Prompt

Run a GEO audit on [URL]. Score: citability, AI crawler access, brand mention presence, schema markup, content factual density, and E-E-A-T signals. Output a full report with prioritized fixes. Then generate an llms.txt file and FAQ schema JSON-LD for the top 3 pages.

To learn more , checkout https://github.com/zubair-trabzada/geo-seo-claude by zubair.

2. SEO + GEO FULL STACK SKILL

your entire SEO + GEO workflow packaged into 20 skills covering: keyword research, content writing, technical audits, and rank tracking for both traditional search and AI platforms using claude code, openclaw , hermes.

All scored against the CORE-EEAT benchmark (80 items) and CITE domain rating (40 items).

Usage

Runs keyword research on Ahref → content gap analysis → full draft → AEO/GEO optimization in a single chained workflow
Audit any page against 80 CORE-EEAT quality criteria and get a scored report with line-level fixes
Generate programmatic SEO pages at scale from a keyword list and a content template
Optimize for AI citations across ChatGPT Search, Perplexity, and Google AI Overviews simultaneously

Prompt

Run the full SEO + GEO workflow for [topic/URL]. 

Step 1: keyword research and gap analysis vs [competitor]. 
Step 2: write a 1,500-word article scored against CORE-EEAT. 
Step 3: apply AEO optimization - add FAQ schema, HowTo markup, and question-phrased headings. 
Step 4: output a GEO readiness score.

You can explore more at: https://github.com/aaron-he-zhu/seo-geo-claude-skills by arron

3. PAID ADS AUDIT SKILL

Running a successful paid campaigns and auditing is a struggle point for many growth team, this skills fixes that.

It first runs 250+ checks across Google, Meta, YouTube, LinkedIn, TikTok, and Microsoft Ads. Based on the result, invoke's parallel agents per platform that scores accounts with weighted rubrics, flags wasted spend, and generates AI-powered creative variants.

Usage

Audit a Google Ads account → get wasted spend breakdown by campaign, ad group, and keyword in one pass
Detect creative fatigue across Meta campaigns → auto-generate 5 replacement hooks per underperforming ad set
Run a CPA spike diagnosis → trace root cause to bid strategy, audience overlap, or landing page mismatch
Get a CMO-ready performance report with scores, benchmarks, and an action plan - all from the terminal

Prompt

Audit this Google Ads account data [attach export]. Run: wasted spend analysis, quality score breakdown, bid strategy assessment, and creative fatigue check. Score each area 0–100 using 2026 benchmarks. Output a prioritized fix list and generate 3 replacement ad copy variants for the lowest-scoring ad groups.

You can learn more at https://github.com/AgriciDaniel/claude-ads by Daniel.

4. FIRECRAWL WEB INTELLIGENCE SKILL

Not something new, similar to firecrawl-claude-plugin, but help’s content team hours by providing claude code / openclaw/ hermes access to live web.

This allows the agent to scrape any page as clean markdown, take full-page screenshots, extract structured data via JSON schema, and crawl entire doc sites. Handles JS rendering and anti-bot automatically.

Usage

Scrape competitor pricing pages weekly → output structured comparison to a Sheet with zero manual copying
Crawl a competitor's entire blog → extract all topics covered → identify content gaps in your own strategy
Pull product reviews from G2, Capterra, or Reddit → auto-summarize into a customer voice report
Run firecrawl x competitor-analysis [URL] in one command to get a full messaging teardown

Prompt

Use Firecrawl to scrape [competitor URL]. Extract: headline, value prop, pricing tiers, key feature claims, and CTA copy. Then scrape [second competitor URL] and output a side-by-side comparison table with a 'gap for us' column."

You can learn more at https://github.com/firecrawl/firecrawl-claude-plugin by firecrawl.

5. DESIGN SKILL

Design is essential aspect of conversion flow, it all starts there. Having a great design that tells a story of the product leads to better conversions. But ai-generated design’s are slop.

This skills fixes that. It extracts design systems from reference UI images and generates implementation-ready design tokens, component specs, and style guides.

This kills the back-and-forth between designer and agent.

Usage

Feed a screenshot of any UI → get a full design system extracted with colors, spacing, typography, and component patterns.
Generate brand-consistent design tokens for a new product from a single reference image.
Audit existing UI for design consistency issues and get a structured fix list.
Bootstrap a complete design system from scratch using decision-tree prompts before a single line of code.

Prompt

Extract the design system from this UI screenshot [attach image]. Output: color palette with hex values, typography scale, spacing system, component inventory, and border/shadow tokens. Then generate a DESIGN_SYSTEM.md I can reference in all future builds.

This one I use almost every weeks. Learn more at: https://github.com/daymade/claude-code-skills

6. REMOTION VIDEO SKILL

Product launch videos can make or break a product lead generation strategy and launch videos are in high demands so charges very high. With this skills you can build your own one, practically for 0$

This skills is official Remotion guidance baked into a SKILL.md. It gives Claude Code the knowledge to generate React-based programmatic videos without hallucinating the API.

Describe a video, get production code.

Usage

Generate a launch announcement video from your product copy - hook, feature highlights, CTA- fully coded in React
Build a weekly metrics video that pulls live data and renders as an MP4 automatically
Create social-ready short-form video assets (16:9, 9:16) from existing blog content
Render music videos from audio files and lyrics using the acestep-simplemv pattern

Prompt

Using Remotion, build a 30-second product launch video for [product name]. 

Scene 1: bold headline on dark background. 
Scene 2: 3 feature callouts with staggered animations. 
Scene 3: CTA with logo. 

Export at 1080x1920 for Instagram Reels. Follow Remotion best practices throughout."

You can learn more at: https://github.com/mxyhi/ok-skills

7. MARKETING PAGE GENERATION SKILL - FRONTEND

Here is another design skill but tailored to marketing page generations, which surprisingly Gemini 3.1 pro does the best, but lacks the color and aesthetic.

This skills instructs Claude / OpenClaw to skip safe, generic aesthetics and commit to bold design decisions. 277,000+ installs.

Best part? Automatically triggers for any frontend task - landing pages, campaign pages, dashboards.

Usage

I use it to :

Generate a full SaaS landing page with hero, features, social proof, pricing, and CTA sections in one pass.
Build campaign-specific microsites from a brief - product, ICP, and tone - without touching Webflow.
Rebuild an underperforming landing page with a distinct visual identity from a reference URL.
Scaffold a complete marketing site with dark mode, responsive layout, and conversion-optimized structure.

Its a great one and I personally use it to build landing pages for product that leads to high conversion rate. Really a must have!

Prompt

Build a landing page for [product]. Target audience: [ICP]. Tone: [direct/editorial/minimal]. Must include: hero with headline + subhead + CTA, 3-feature section, social proof strip, and pricing table. Choose a bold, distinctive aesthetic - not generic SaaS. Output production-ready HTML/CSS/JS or React + Tailwind.

Give it a try at https://github.com/anthropics/claude-code/tree/main/plugins/frontend-design

8. CONTENT OPS SKILL

Your entire content operations workflow under one skill.

It contains 8 skills that covers: production, audit, repurposing, and distribution. Works as a full editorial pipeline: from brief to published inside Claude Code or OpenClaw.

Simply put, its a swiss army knife for content and growth team as well.

Usage

Run a full content audit: feed your sitemap → agent scores each page by intent, keyword alignment, and conversion potential → outputs prioritized fix list
Repurpose one long-form piece → 5 tweet threads + 3 LinkedIn posts + 1 newsletter section in one command
Generate a 12-week content calendar from your ICP, product pillars, and keyword list
Auto-draft blog posts from raw notes or voice transcripts, following your brand voice file

Prompt

Run a content ops workflow for [topic/URL]. Step 1: audit existing content for gaps vs [keyword cluster]. Step 2: generate 4 new content briefs targeting missed keywords. Step 3: draft post #1 in full using our brand voice [attach]. Step 4: repurpose it into 3 LinkedIn posts and a tweet thread

Get your content pipeline started: https://github.com/superamped/ai-marketing-skills by superramped.

While the content pipeline works, but it may still feel ai-generated, so pair it with last skill and see the organic growth.

9. HUMANIZER SKILL - DE-SLOP YOUR CONTENT

The biggest problem right now with social media is AI generated slop. If you are someone who use ai to generate post and directly post, you need to stop!

Instead use the Humanizer Skill.

It’s a 8-pass editing system that detects and kills AI writing patterns before your content goes live. Strips banned vocabulary (delve, tapestry, foster), breaks structural tells, and forces organization & soul back into the copy.

Usage

Paste any AI-generated blog post → get a rewrite that sounds like a person with opinions wrote it, not a language model.
Run on cold email sequences before sending → eliminates the "this was clearly written by AI" reply-killing patterns.
Match a specific human voice by feeding 2-3 paragraphs of your own writing as a style reference before humanizing.
Use after every content ops skill output. This makes the pair unstoppable for publishing-ready content at scale.

Prompt

Humanize this text: [paste]. First, scan for AI vocabulary, structural tells, and rhythm patterns. Then rewrite in 3 passes: 
- kill AI words, break parallel structures, add human texture and opinion. 
- Run an audit pass 
- list everything still obviously AI then do a final rewrite. 
Match this voice sample: 

[paste 2 paragraphs of your own writing].

Link: https://github.com/jpeggdev/humanize-writing

Bonus Skills - A Toolbox for Marketing Teams

Here are some additional skills with a brief one liner of what they do. Often good to pair with other skills output.

create-viral-content
- Encodes the refinement process that separates forgettable posts from ones that generate discussion and shares.
- Runs AI-tell detection after every draft, then auto-invokes the humanizer for the final pass
awesome-openclaw-skills
- lead-gen-crm + lead-scorer-free
- Two OpenClaw skills that chain into a full outbound pipeline.
- lead-scorer-free scores any domain 0–100 by analyzing its website, DNS, sitemap, and social presence. No database subscription needed.
- lead-gen-crm handles the full CRM pipeline from that point.
cold-outreach
- Uses Alex Hormozi Frameworks for cold-outreach.
- Generates high-converting cold outreach across email, SMS, and LinkedIn DM.
- Uses battle-tested Hormozi offer frameworks baked directly into the skill.
- Not generic copy - structured around irresistible offer construction.
marketing-psychology
- Applies cognitive biases, mental models, and behavioral science frameworks directly to marketing copy, CRO, and funnel design.
- Cialdini, Kahneman, and Ariely strategy and research baked into a skill.

That marks the end of this article. Here are some hidden insights that I discovered while using these.

Final Thoughts

Use chain of skills to get the output that makes the product position unique and well framed.

Simple example:

Use content ops skill to draft the long-form piece
Pass it to psychological persuasion skill rewrites every headline and CTA against 12 cognitive bias principles
Humanizer strips every AI tell across 8 passes → what's left sounds like your sharpest human writer, not a model hitting word count
Cold Outreach pulls the strongest pain observations and proof points from that copy → lands in your ICP's inbox as a Hormozi-framed 5-email sequence and 3 LinkedIn DMs.

The hard part isn't the skills - it's orchestrating the flow between them. That's where Composio comes handy.

It handles the auth layer, manages tool calls across every integration, and keeps context intact as output moves from one skill to the next. No glue code. No dropped state. No manual handoffs.

Install it once. Let it run the pipeline while you focus on what AI still can't do - knowing your customer well enough to say something worth reading.

Building a Financial Agent That Actually Works: Composio MCP + Hermes

Developer Harsh — Thu, 16 Apr 2026 04:30:09 +0000

I recently explored Hermes Agent to see how far I could push autonomous workflows in a real-world use case.

Instead of just experimenting,
I wanted something practical, so I decided to build a financial analyst agent that could fetch, process, reason over financial data and suggest me stocks in this era of war.

This blog post walks through exactly how we:

Securely Set up Hermes Agent
Integrated Composio MCP for tool access (Google Sheet, Google Doc, Exa)
Built a functional financial analyst agent that captures the market trends

Along the way, I’ll also share what broke, what worked, and what I’d do differently.

What is Hermes Agent

Hermes Agent an open source AI agent that can learn and evolve as you interact in real-time , something that open-claw lacked.

It does so by using a persistent cross-session memory and closed learning loop (write docs → save tools → update memory) that converts completed task into reusable skills. This allows it become more efficient over time.

The agent has following key capabilities:

S*elf Improving Loop* : Unlike standard chatbot wrappers, Hermes agent refines its own skills from completed task
Persistent Memory: Maintains a persistent model of the user and past interactions across sessions.
Autonomous Agent tools: Agent offers over 40+ built in tools, support sub agent delegation and code execution
Multi-Platform Integration: Works from anywhere , from terminal to plethora of social media service (though little buggy)
Model Agnostic: Supports multiple LLM providers and LLMS including open source and closed source models.

Think of it as a programmable agent that can reason + act + self improve , not just respond.

This means its a perfect candidate for a financial analyst agent.

Securely Setup Hermes Agent

Prerequisites:

Docker - Install docker desktop
Optional- WSL2 for Windows

First install herms in docker, open terminal and run one by one:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc

Next configure the Hermes Agent, here is the setting I choose, feel free to choose your preferred:

Provider : OpenAI Codex. Make sure to authenticate
Model : GPT 5.4 / GPT 5.4 mini ( for faster inference)
TTS: Keep Current
Terminal Backend: Docker (make sure either docker is installed / docker desktop running)
Docker image : default
Max Iterations : Default. Set this to higher for complex task (cost more token)
Context Compression Threshold: Default. Higher threshold compresses later and lower does it faster
Messaging Platform (optional) : Choose Telegram and follow the instructions. Rest same , but I kept only telegram.

If done all this you will be greeted with following screen

Now time to add Composio MCP!

Hermes by default provide ~40 tools, which is ok for daily tasks.

But it starts feels pretty limited when you start building complex agentic workflows where you need to connect multiple third party SaaS apps (Google Doc, Sheets, Web seach tools, etc) with prod grade security and calling them at need.

Composio is the tooling layer that sits between Hermes Agent and third party applications and let you connect to 1000+ tools with secure auth and intelligent tool calling.

Installing Composio MCP is quite straightforward. Follow these steps:

Head to the https://dashboard.composio.dev/ & login. You will be greeted with this dashboard

Head to the Install & copy the MCP Url and X-CONSUMER-API-KEY value

Once done head to the terminal and type :

nano ~/.hermes/config.yaml

and at the end add these lines:

mcp_servers:
  composio:
    url: "https://connect.composio.dev/mcp"
    headers:
      x-consumer-api-key: "YOUR_COMPOSIO_API_KEY"
    connect_timeout: 60
    timeout: 180

Add your own api key you copied & save the file

Now, head back to Hermes Agent and restart it using hermes, and it will detect the mcp.

Now you can use Hermes Agent with MCP like any other agent, even though code runs in the sandbox:).

Alright now that we have agent & mcp in place, let’s try to see how it performs.

Add MCP using Composio CLI (Optional)

Composio also has a CLI, which let’s any agent to communicate with all the tools through commands. The CLI allows composability of workflows. The agent can chain tools and accomplish complex tasks with relatively lesser tokens than MCPs.

Using it is straight forward. Open your Hermes agent and paste the prompt mentioned on https://composio.dev/cli :

INSTALL (run in user's terminal)
  curl -fsSL https://composio.dev/install | bash

You have access to 1000+ app integrations through these commands.
search → find tools. execute → run them. link → connect accounts.
proxy → raw API access. run → inline scripts.

Bias toward action: run `composio search <task>`, then `composio execute <slug>`.
Input validation, auth checks, and error messages are built in — just try it.

USAGE
  composio <command> [options]

CORE COMMANDS
  search
    Find tools. Use this first — describe what you need in natural language.
    Usage: composio search <query> [--toolkits text] [--limit integer]
      <query>             Semantic use-case query (e.g. "send emails")
      --toolkits          Filter by toolkit slugs, comma-separated
      --limit             Number of results per page (1-1000)

  execute
    Run a tool. Handles input validation and auth checks automatically.
    If auth is missing, the error tells you what to run. Use aggressively.
    Usage: composio execute <slug> [-d, --data text] [--dry-run] [--get-schema]
      <slug>              Tool slug (e.g. "GITHUB_CREATE_ISSUE")
      -d, --data          JSON or JS-style object arguments, e.g. -d '{ repo: "foo" }', @file, or - for stdin
      --dry-run           Validate and preview the tool call without executing it
      --get-schema        Fetch and print the raw tool schema

  link
    Connect an account. Only needed when execute tells you to — don't preemptively link.
    Usage: composio link [<toolkit>] [--no-browser]
      <toolkit>           Toolkit slug to link (e.g. "github", "gmail")

  run
    Run inline TS/JS code with shimmed CLI commands; injected execute(), search(), proxy(), subAgent(), and z (zod).
    Usage: composio run <code> [-- ...args] | run [-f, --file text] [-- ...args] [--dry-run]
      <code>              Inline Bun ESNext code to evaluate
      -f, --file          Run a TS/JS file instead of inline code
      --dry-run           Preview execute() calls without running remote actions

  proxy
    curl-like access to any toolkit API through Composio using your linked account.
    Usage: composio proxy <url> --toolkit text [-X method] [-H header]... [-d data]
      <url>               Full API endpoint URL
      --toolkit           Toolkit slug whose connected account should be used
      -X, --method        HTTP method (GET, POST, PUT, DELETE, PATCH)
      -H, --header        Header in "Name: value" format. Repeat for multiple.
      -d, --data          Request body as raw text, JSON, @file, or - for stdin

  artifacts
    Inspect the cwd-scoped session artifact directory and history.
    Usage: composio artifacts cwd
      cwd                 Print the current session artifact directory path

  Workflow: search → execute. If execute fails with an auth error, run link, then retry.

TOOLS
  tools info <slug>     Print tool summary and cache its schema
  tools list <toolkit>  List tools available in a toolkit
  artifacts cwd         Print the cwd-scoped session artifact directory

EXAMPLES
  # 1. User asks you to "create a GitHub issue"
  composio search "create github issue"
  # → returns GITHUB_CREATE_ISSUE

  # 2. Execute it (will error if not linked — that's fine)
  composio execute GITHUB_CREATE_ISSUE -d '{ repo: "owner/repo", title: "Bug" }'
  # → if auth missing: "Run `composio link github` first"

  # 3. Link only when told to
  composio link github

  # 4. Raw API access when no tool exists
  composio proxy https://gmail.googleapis.com/gmail/v1/users/me/profile --toolkit gmail

  # 5. Run a script with injected helpers
  composio run 'const me = await execute("GITHUB_GET_THE_AUTHENTICATED_USER"); console.log(me)'

DEVELOPER COMMANDS
  dev       Developer workflows: init, playground execution, triggers, and logs.
  generate  Generate type stubs for toolkits, tools, and triggers (TypeScript | Python).
  manage    Manage orgs, toolkits, connected accounts, triggers, auth configs, and projects.

ACCOUNT
  login    Log in to Composio
  logout   Log out from Composio
  whoami   Show current account info
  version  Display CLI version
  upgrade  Upgrade CLI to the latest version

FLAGS
  -h, --help     Show help for command
  --version      Show composio version

LEARN MORE
  Use `composio <command> --help` for more information about a command.
  Documentation: https://docs.composio.dev

GETTING STARTED
  When your user asks you to do something with an external app:
  1. composio search "<what they want done>"
  2. composio execute <slug from search> -d '<params>'
  3. If auth error → composio link <toolkit>, then retry step 2.

  Do not assume we lack coverage. Search first — we likely support it.
  Do not preemptively link accounts or ask your user what to connect.
  Just try. Auth and validation errors are self-descriptive.

This set’s agent to use Composio cli and do all the task, rather than using direct mcp - infact this approach much simpler as no dependency is required.

Alright now that we have agent & mcp in place, time to build the financial agent

Building A Financial Analyst Agent

Head to the Hermes Agent, if not active - enable it using Hermes , ensure the MCP section have Composio and all other relevant MCP’s showing up (Gmail, Google Sheet, Google Docs , Exa Search). This is essential.

Now in the prompt box, paste the following prompt:

You are my personal Indian stock market financial analyst. Start by asking me exactly 5 screening questions one at a time to assess my risk appetite (cover: risk tolerance, investment horizon, capital range, sectors of interest, and reaction to loss). Once done, analyze my answers and begin your analyst workflow:

**Setup:** Attempt to use Google Docs, Google Sheets, and Gmail via your Composio tools. If any are not connected, Composio will automatically generate a sign-in link — share it with me, wait for me to authenticate, then resume once all connections are active.

**Every 5 minutes, run this loop:**

1. **Data Gathering:** Pull live Indian stock market data from multiple sources in parallel:
   - **Exa Search Tool:** Use composio Exa tool to search for latest Indian stock market news, analyst reports, earnings updates, sector trends, and breaking financial events. Query terms like "NSE BSE India stocks today", "Indian market sentiment", "Nifty Sensex analysis", top sector movements, and any stock-specific news relevant to my risk profile.
   - **Free Financial APIs & Web Sources:** NSE India API, BSE India, Yahoo Finance India, Moneycontrol, Tickertape, Economic Times Markets, and any other authoritative free real-time Indian market feeds available to you.
   - Cross-reference and reconcile data from both sources for accuracy before analysis.

2. Analyze all gathered data against my risk profile.

3. **Google Doc:** Search for an existing doc named "Hermes Financial Report - India". If found, append a new report section separated by `---`. If not, create it. Each report must be clean, well-structured with proper headings, and include: timestamp, market summary, macro indicators, top picks with clear reasoning, what to avoid and why, and a decisive final recommendation paragraph. Use proper spacing, bold headers, and bullet points for readability.

4. **Google Sheet:** Search for an existing sheet named "Hermes Stock Tracker - India". If found, append new rows. If not, create it. Format the sheet with bold column headers, frozen top row, and color-coded sentiment (Bullish = green, Bearish = red, Neutral = yellow where possible). Columns: Stock Name | Ticker | Exchange (NSE/BSE) | Sector | Market Sentiment (Bullish/Bearish/Neutral) | My Prediction (Yes/No) | Confidence % | Min Investment (INR) | Last Updated.

5. **Hourly Email via Gmail:** After every report cycle, send me a well-formatted email with:
   - **Subject:** 📊 Hermes Market Report — [Date & Time IST]
   - **Body:** A brief 3–5 line market summary, top 3 stock picks with one-line reasoning each, one key risk to watch, and direct clickable links to the updated Google Doc and Google Sheet.
   - Keep the email clean, scannable, and professional — use spacing, bold labels, and short paragraphs.

**Urgent Signal Alert (send immediately, outside the hourly loop):** If at any point you detect a strong buy or sell signal (significant price movement, breaking news from Exa or any financial source, sentiment shift, or macro event affecting Indian markets), instantly send a separate alert email with:
   - **Subject:** 🚨 URGENT: [BUY/SELL] Signal — [Stock Name] — [Time IST]
   - **Body:** Stock name, ticker, exchange, signal type (Buy/Sell), reason in 2–3 crisp lines, recommended action, and link to the Google Doc & Google Sheet for full context.

Never stop the loop unless I say stop. Be decisive, data-driven, and always flag urgency clearly.

With this prompt:

You get asked 5 questions, and it builds a personal risk profile tailored to your investment style.
Every hour, it automatically scans NSE, BSE, Exa, Yahoo Finance, Moneycontrol and more for live Indian market data.
It writes a detailed investment report (what to buy, what to avoid, why) into a Google Doc - appending fresh analysis every cycle.
It maintains a live Google Sheet tracking top Indian stocks with sentiment, prediction, confidence, and minimum investment amount.
It emails you a clean market summary every hour, and fires an instant alert the moment it spots an urgent buy or sell signal.

Note: For demo i set the 1 hour duration to 5 minutes.

Now wait for execution to finish and cron job to be created. This is what my flow looked like:

Agent by default didn’t had access to Gmail, Sheet, Docs & EXA, and manually adding them was a pain (if say 20+ tools) and it bloats the context window as well.

Composio solves the issue. You add it once, and it takes care of: - OAuth (one time link- did beforehand),

calling right tool at runtime when needed,
performing all the actions in sandbox and
deliver the result, while Hermes Agent handled the orchestration and reasoning.

Note : If you haven’t connected any tool, while running agent, agent will ask you to connect, authenticate. Also for EXA - use a api key.

Best Agents SDK in 2026

Developer Harsh — Fri, 03 Apr 2026 14:59:51 +0000

AI agents are no longer experimental. They are being shipped in production systems right now, and the SDKs powering them have matured dramatically.

If you're building with AI in 2026, understanding the tools available to you is no longer optional.

OpenAI, Claude, and Google are providing their SDKs to build these agents in minimal code for production. With their own quirks, they can make it harder for businesses and developers alike.

I just did a comparison between the top most used frameworks:

Claude Agent SDK
OpenAI Agents SDK
Google ADK

All source code at the end!

Let’s begin.

Why This Comparison?

First thing’s first, why this comparison, while many others already existed, here is the deal:

I’ve been building agents across these SDKs, and the reality is they all promise “minimal code” but behave very differently once you go beyond demos.

So I compared them the only way that matters: by actually building with them.

I looked at:

how quickly I could get something working,
how much control I had when things got complex, and
how they handled real-world workflows like multi-agent coordination, tool usage, and state management.

Here are all my findings.

OpenAI Agents SDK

The OpenAI Agents SDK is an open-source framework and a significant upgrade over Swarm. It is designed to simplify orchestrating multi-agent workflows.

It is Python & TS-first. Developers use built-in language features to orchestrate and chain agents rather than learning new abstractions.

Core Primitives

Agents: LLMs with instructions, tools, guardrails, and handoffs.
Handoffs: Delegating tasks to other agents.
Tools: Functions, MCP, and hosted tools.
Guardrails: Safety checks for input/output validation.
Sessions: Automatic conversation history management.
Tracing: Built-in visualization for debugging.

Why Use It

Multi-Language Support: Provider-agnostic. Supports OpenAI APIs and 100+ other LLMs.
Realtime & TTS Voice: Build voice agents with interruption detection and context management.
Observability: Robust tracing exports to Logfire, AgentOps, or OpenTelemetry.
Advanced Connectivity: Supports WebSocket transport for Responses API and SIP protocol connections.
GPT-5.x Ready: Updated reasoning effort and cleaner handoff history for downstream context.

Ease of Getting Started

Minimal setup: Requires just a few lines of code.
Quick install: pip install openai-agents. Runs in under 10 lines.
Suited for: Teams wanting rapid prototyping and simple agent coordination.

Developer Experience

Python-first: Express complex relationships with a small set of primitives.
Type Safety: Zod-powered validation for TypeScript/JavaScript.
Visual Tooling: Agent Builder provides a drag-and-drop canvas for composing logic.

Example

I used OpenA Agents SDK to build me a job search agent, that fetches me jobs based on the user persona it created by asking me relevant questions.

By default, openai agents is unable to use exa search, google sheets, this is where composio handle’s that, not only that, but you can also connect it to over 850+ tools and integrations.

This is the code that handled all the heavy lifting

# imports 
from composio import Composio
from composio_openai_agents import OpenAIAgentsProvider

# Initialize Composio
composio = Composio(api_key=api_key, provider=OpenAIAgentsProvider())

# Create Tool Router session (connection tools + wait so OAuth can finish before continuing)
session = composio.create(
    user_id=user_id,
    toolkits=["GITHUB", "exa", "googlesheets", "browser_tool" ],
    manage_connections={"enable": True, "wait_for_connections": True},
)
mcp_url = session.mcp.url

# add tool_configs
agent = Agent(
    name="Assistant",
    model="gpt-5",
    instructions=("..."),
    tools=[
        HostedMCPTool(
            tool_config={
                "type": "mcp",
                "server_label": "tool_router",
                "server_url": mcp_url,
                "headers": {"x-api-key": api_key},
                "require_approval": "never",
            }
        )
    ],

One thing that stand out was, not only agent created a right persona based on screening question, but also fetched me list of relevant job description along with my skills relevancy, without explicitly told to do so.

Claude Agent SDK

The Claude Agent SDK is Anthropic's open-source framework for building agents that interact with a real computer.

It evolved from Claude Code. The core principle is simple: give your agent a computer. It uses a shell, a file system, and the web just like a human.

Core Primitives

Bash tool: Executes shell commands directly.
Read / Write / Edit: Native file system access.
Glob & Search: File discovery across project directories.
Subagents: Spawn parallel or nested agents for subtasks.
MCP servers: Standardized integrations (Slack, GitHub, Google Drive).
Permission modes: Fine-grained control via allowed_tools and permission_mode.

Why Use It

Native OS Access: The only SDK where agents directly control a computer.
In-Process Tools: Custom tools run inside your Python app. No separate process needed.
Multi-Cloud: Supports AWS Bedrock, Google Vertex AI, and Microsoft Azure AI Foundry.
Xcode 26 Integration: Full Claude Code power inside the IDE, including capturing Xcode Previews.

Ease of Getting Started

Minimal entry point: Built-in tools mean no manual plumbing.
Quick install: pip install claude-agent-sdk.
Best for: Developers needing deep OS access or agentic coding workflows.

Production Readiness

Battle-proven: Powers Anthropic’s internal research and video creation.
Context Compaction: Automatic management for long-running tasks.
Cost Controls: max_budget_usd parameter caps spend per session.

Example

I used Claude Agent’s SDK to build an open-source contributor, which takes a repo name, fetches a good issue listed, reads the contribution file, fork’s the repo, create the code fix that matches orignal repo style, push the code to forked repo and raises a PR.

By default, calude agents is unable to use github, this is where composio handle’s that, not only that, but you can also connect it to over 850+ tools and integrations.

This is the code that handled all the heavy lifting

# imports
from composio import Composio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

# fetch all composio toolkits name
def _toolkits() -> list[str]:
    raw = os.getenv("OSS_COMPOSIO_TOOLKITS")
    if raw:
        return [t.strip() for t in raw.split(",") if t.strip()]
    return list(DEFAULT_TOOLKITS)

# create a async chat, connect to composio, fetch user id, define toolkits and mcp server url + configs.
async def chat_with_oss_stack() -> None:
    api_key = os.getenv("COMPOSIO_API_KEY")
    if not api_key:
        raise RuntimeError("COMPOSIO_API_KEY is not set")

    composio = Composio(api_key=api_key)

    user_id = os.getenv("COMPOSIO_USER_ID") or os.getenv("USER_ID")
    if not user_id:
        raise RuntimeError(
            "Set COMPOSIO_USER_ID (or USER_ID) in the environment or .env — Composio needs a stable user id string."
        )

    kits = _toolkits()
    mcp_server = composio.create(
        user_id=user_id,
        toolkits=kits,
    )

    url = mcp_server.mcp.url
    if not url:
        raise ValueError("Session URL not found")

    options = ClaudeAgentOptions(
        permission_mode="bypassPermissions",
        mcp_servers={
            "composio": {
                "type": "http",
                "url": url,
                "headers": {
                    "x-api-key": os.getenv("COMPOSIO_API_KEY", ""),
                },
            }
        },
        system_prompt=OSS_SYSTEM_PROMPT,
        max_turns=int(os.getenv("OSS_MAX_TURNS", "40")),
    )

I asked it to operate on “gemini-cli” repository, and it create a pr for me.

Google Agent Development Kit (ADK)

Google's ADK is a code-first framework. It applies engineering principles like versioning, testing, and modularity to AI.

While optimized for Gemini, it is model-agnostic and built for compatibility with third-party tools.

Core Primitives

LLM Agents: Use LLMs as the reasoning core.
Sequential/Parallel/Loop Agents: Predictable pipeline execution.
Graph-based workflows: (ADK 2.0 Alpha) Conditional, branching pipelines.
Agent2Agent (A2A): Secure protocol for agent-to-agent delegation.
ADK Web UI: Browser-based interface for inspecting traces and artifacts.

Why Use It

Widest Language Support: Python, TypeScript, Java, and Go.
Complex Orchestration: Graph-based logic for branching and retry paths.
Secure Interoperability: A2A allows delegation without exposing internal memory.
Vertex AI Integration: Deploy directly to Google Cloud’s managed enterprise runtime.

Ease of Getting Started

Under 100 lines: Build production agents with bidirectional audio/video.
Agent Starter Pack: Accelerated deployment path for Google Cloud services.
Best for: Enterprise-grade systems requiring tight Google ecosystem integration.

Developer Experience

Advanced State Management: Restores state from failure and allows context "rewinding."
Enterprise Governance: Integration with Cloud API Registry to curate approved tools.
Pre-built Connectors: 100+ connectors via Composio.

Example

For demos these are cool, heard people say, can be used in production, but it failed most of tool calls, racked me up a bill of 5$ due to repeated tool call (was stuck in thinking loop). Also the rate limit on free tier is real pain.

Yes, its developer friendly, but really lacks a lot in terms of performance and newbies can easily stuck with adk web or adk cli as it requires a specific folder structure.

However for simpler task it did quite well. Built an email agent that maps promotional education mails (like coursera, deeplearning) to well optimised developer roadmap, which beginner devs can use to learn in a structured manner.

Suprisingly code to use composio tools here is quite simple and easy to use:

# imports
from composio import Composio
from composio_google import GoogleProvider

# load envs
COMPOSIO_API_KEY = os.getenv("COMPOSIO_API_KEY")
COMPOSIO_USER_ID = os.getenv("COMPOSIO_USER_ID")

# create composio client
composio_client = Composio(
    api_key=COMPOSIO_API_KEY,
    provider=GoogleProvider(),
    timeout=120,
    max_retries=5,
)

# create a client session with tools
composio_session = composio_client.create(
    user_id=COMPOSIO_USER_ID,
    toolkits=["gmail"],
)

# store sessiom url
COMPOSIO_MCP_URL = composio_session.mcp.url

# add composio mcp server connection
composio_toolset = McpToolset(
    connection_params=StreamableHTTPConnectionParams(
        url=COMPOSIO_MCP_URL,
        headers={"x-api-key": COMPOSIO_API_KEY},
        timeout=30.0,
        sse_read_timeout=600.0,
    )
)

# include it in the agents
root_agent = Agent(
    model="gemini-2.5-flash",
    name="composio_agent",
    description="An agent that uses Composio tools to perform actions.",
    instruction=(
        "You are a helpful assistant connected to Composio. "
        "You have the following tools available: "
        "COMPOSIO_SEARCH_TOOLS, COMPOSIO_MULTI_EXECUTE_TOOL, "
        "COMPOSIO_MANAGE_CONNECTIONS, COMPOSIO_REMOTE_BASH_TOOL, COMPOSIO_REMOTE_WORKBENCH. "
        "Use these tools to help users with GMAIL operations."
    ),  
    tools=[composio_toolset],
)

Comparison Table

Feature	OpenAI Agents SDK	Claude Agent SDK	Google ADK
Primary Language	Python, TypeScript	Python, TypeScript	Python, TS, Java, Go
Model Agnostic	✅ (100+ LLMs)	⚠️ (Claude-first)	✅ (Gemini-optimized)
Multi-Agent	✅ Handoffs	✅ Subagents	✅ Graph (2.0 Alpha)
OS Access	❌ No native control	✅ Native Bash/File	❌ No native control
Voice/Realtime	✅ Built-in	⚠️ Via API	⚠️ Via API
Best For	Voice & LLM diversity	OS/File automation	Enterprise/Google Cloud

Which One to Choose?

OpenAI Agents SDK: Choose if you want a lightweight framework with strong voice support and the ability to swap LLMs freely.
Claude Agent SDK: Choose if your agents need deep OS access (developer assistants) or follows a "give the agent a computer" paradigm.
Google ADK: Choose if you are building enterprise-grade systems on Google Cloud or need multi-language support (Python/Java/Go). Requires lot of manual plumbing and security.
For better

Final Thoughts

OpenAI, Claude, and Gemini are all key players. However, the real competitive edge isn't knowing that these SDKs exist. It's the hands-on mastery of architectural decisions:

When to use a handoff versus a subagent.
How to design tools that don't bloat the context window.
When to insert a human checkpoint.

Frameworks evolve quickly. The deeper intuition for architecting reliable systems only comes through repeated experimentation.

All agents source code can be seen at https://github.com/DevloperHS/agents-sdk-tests. Feel free to fork and raise pr’s :)

Happy Building.

Top 10 OpenClaw Plugins to Supercharge Your OpenClaw Workflows

Developer Harsh — Wed, 18 Mar 2026 05:03:35 +0000

The Rise of OpenClaw Plugins

If you've worked with OpenClaw, you already know Skills, the task-level instructions that let your agent send emails, query APIs, or pull live data.

But plugins operate at a deeper layer. They hook into the agent's lifecycle, reshape how it reasons, authenticates, and interacts with the outside world.

Though OpenClaw currently has a very limited set of official plugins, many independent devs have built some really cool plugins.

And it seems OpenClaw plugins are going to get a huge push from OpenClaw.

Top OpenClaw Plugins

As an OpenClaw enthusiast, I collated some of the actually useful plugins for OpenClaw.

Composio - Connect OpenClaw with 850+ on-demand SaaS Apps
memU (Memory Framework) - Hierarchical Knowledge Graph That Makes Your Agent Proactive
SecureClaw - OWASP-Aligned Security Auditing and Runtime Hardening
Lobster - Typed Workflow Pipelines with Approval Gates for Reliable Automation
Memory LanceDB - Vector-Backed Long-Term Memory with Auto-Recall and Auto-Capture
MemOS Cloud - Cloud-Hosted Cross-Agent Memory with Async Recall and Isolation
OpenClaw Foundry - Self-Writing Meta-Extension That Learns and Builds Its Own Tools
Better Gateway - Auto-Reconnect, Embedded IDE, and Browser Terminal for Stable Ops
Voice Call - Outbound Phone Calls and Multi-Turn Voice Conversations via Twilio

1. Composio

Connect OpenClaw with 850+ on-demand SaaS Apps

nstead of installing individual skills for every app (Gmail, GitHub, Outlook, Notion), this single plugin connects to Composio’s managed MCP server and handles all OAuth and authentication logic automatically.

This plugin is the official bridge that allows your OpenClaw agent to discover and call any SaaS tools dynamically.

Pre-requisites

Log in at dashboard.composio.dev
Choose your preferred client (choose OpenClaw)
Copy your consumer key (ck_...)

Set OpenClaw Config

Then, allow Composio tools in your agent's tool list. This works with any tool profile (coding, minimal, messaging, etc.). Without this step, Composio tools will only be available on the full tool profile:

After setting your key and allowing the tools, restart the gateway:

Result (in ~/openclaw/openclaw.json file):

2. memU (Memory Framework)

Hierarchical Knowledge Graph That Makes Your Agent Proactive

A proactive long-term memory plugin that replaces standard flat-file memory.

It builds a hierarchical knowledge graph of your preferences and projects, allowing the agent to anticipate needs rather than just reacting to prompts.

Simple examples include: "You have a meeting in 10 minutes; should I pull the latest briefing?"

If you want to add a robust memory layer for the agent to handle missing context, go for it.

GitHub Repo: https://github.com/duxiaoxiong/memu-engine-for-OpenClaw

Installation

openclaw plugins install @memu/memu-engine

3. SecureClaw

OWASP-Aligned Security Auditing and Runtime Hardening

The industry-standard security plugin.

It hardens the agent's runtime by mapping actions to the OWASP Top 10 for Agents. It provides real-time auditing and prevents prompt injection attacks from reaching your system shell.

If you are concerned about OpenClaw security while running on vm’s or locals (not recommended), this plugin can give you a sigh of relief.

GitHub Repo: https://github.com/adversa-ai/secureclaw

4. Lobster

Typed Workflow Pipelines with Approval Gates for Reliable Automation

A powerful scripting plugin that turns complex multi-step skills into repeatable, typed pipelines.

This means, instead of the agent "guessing" the next step, Lobster ensures high-reliability execution for production-grade automations.

It does it through typed JSON-first pipelines, jobs, and approval gates & let OpenClaw call the workflows in one step.

If you like to automate tasks using your skills, this will make your job easier than ever.

GitHub Repo: https://github.com/openclaw/lobster

Installation

Lobster is a bundled tool — enable it in your configuration.

5. Memory LanceDB

Vector-Backed Long-Term Memory with Auto-Recall and Auto-Capture

The default memory-core plugin stores memory as flat Markdown files. memory-lancedb replaces it with a proper vector-backed long-term memory store using LanceDB.

Set plugins.slots.memory = "memory-lancedb" and your agent gets auto-recall (relevant memories injected before every turn) and auto-capture (important facts stored after every turn) — without you having to manually write to MEMORY.md.

It supports multiple embedding providers (OpenAI, Gemini, Ollama), includes prompt-injection detection for captured memories, and provides a CLI for searching and managing stored memories.

If your agent keeps "forgetting" things between sessions or after context compaction, this is the first plugin you should install.

GitHub Repo: https://github.com/noncelogic/openclaw-memory-lancedb

6. MemOS Cloud

Cloud-Hosted Cross-Agent Memory with Async Recall and Isolation

MemOS Cloud is a lifecycle plugin that recalls relevant memories from the MemOS Cloud API before each agent run and saves new conversation data after each run.

It works asynchronously, supports cross-agent memory isolation via agent_id, and lets you configure limits on how many memories are injected per turn.

Where memory-lancedb stores everything locally, MemOS Cloud is the right choice when you need cloud-hosted memory that persists across devices, or when you're running multi-agent setups where agents need isolated but centrally managed memory.

It's a great complement to LanceDB — use LanceDB for local-first setups, and MemOS Cloud when you need cloud persistence or multi-agent coordination.

GitHub Repo: https://github.com/MemTensor/MemOS-Cloud-OpenClaw-Plugin

7. OpenClaw Foundry

Self-Writing Meta-Extension That Learns and Builds Its Own Tools

Foundry is a self-writing meta-extension. It observes your workflows, researches the OpenClaw docs, and writes new skills, extensions, hooks, and tools directly into your setup.

The self-modification loop actually works: Foundry validates generated code in a sandbox before deploying it, records patterns from successes and failures, and can even extend its own capabilities.

It includes tools like

foundry_implement (end-to-end research + build),
foundry_write_skill,
foundry_write_hook,
and foundry_extend_self

making it the closest thing to an agent that builds its own tools.

GitHub Repo: https://github.com/lekt9/openclaw-foundry

8. Better Gateway

Auto-Reconnect, Embedded IDE, and Browser Terminal for Stable Ops

The stock OpenClaw gateway drops WebSocket connections under load.

Better Gateway fixes this with automatic reconnection, configurable retry intervals, and a status indicator that shows connection health in real time.

Beyond stability, it adds a Monaco-based IDE and a full xterm.js terminal directly into the gateway UI — no extra ports, no SSH tunneling needed. Everything runs on the main gateway port.

It also exposes a file API for workspace read/write/list/delete operations, making it a practical all-in-one development environment for your OpenClaw setup.

If you run OpenClaw on a remote server or VPS, this plugin is essential for a smooth development experience.

GitHub Repo: https://github.com/ThisIsJeron/openclaw-better-gateway

9. Voice Call

Outbound Phone Calls and Multi-Turn Voice Conversations via Twilio

I have kept the best one for the last, and it's the most transformative plugin of the year.

Voice Call moves OpenClaw beyond text by enabling outbound phone calls and multi-turn voice conversations via Twilio or Telnyx.

It’s widely used for "reach me anywhere" notifications and for real-world tasks like booking appointments, as shown in YouTube/Twitter demo videos.

Throw it leads, client, follow up, it handles all, with just a single setup. Game changer in voice call automations.

So, if you are a business owner who has to call a lot of people, this plugin is for you.

Installation

GitHub Repo: https://github.com/openclaw/openclaw/tree/main/extensions/voice-call

In case you want speed, you can check community one: VoiceClaw- DeepGram Plugin

And with that, we have reached the end of this short, definitive plugin list.

Final Thoughts

Plugins run silently in the background, shaping how your agent thinks and responds at a system level. It’s really a more integrated experience than just skills.

How to unlock 850+ tools in OpenClaw

Developer Harsh — Wed, 11 Mar 2026 12:48:25 +0000

OpenClaw Limitations Unlocked

Openclaw comes with pretty limited set of tools. They are powerful but restricts a lot of functionality.

What if a single one can give you access to plethora of tools that works at your command.

There is a hidden benefit too - you don't have to share your credentials with open claw, making your OpenClaw workflows secure.

Enter's Composio - a tool layer for OpenClaw and all ai agents that offer self-tool discovery and selection, e2e authentication and no vendor lock in.

Why use it?

Composio expand's capabilities while keeping authentication secure and data under your control.

So, it's just plug and play - you plug in, connect your tools, and start building things that actually matter.

Now Let's look at how to connect composio with OpenClaw in this short guide.

3 Ways to connect opne claw

Here are 3 ways to connect openclaw:

Direct prompt
Composio npm package
MCP Porter

Let's look at how to set it up

1. Direct Prompt

Best part about open claw is - it can auto execute tools and setup your tools using a single prompt.

You can use that to your advantage and open up the OpenClaw dashboard chat and paste the following prompt:

Add a new MCP server called "composio" with transport type HTTP. Use the URL https://connect.composio.dev/mcp and add the header "x-consumer-api-key: your-api-key".

Make sure to replace your-api-key with actual composio api key. You can get that by:

Visiting to Composio Dashboard and sign up / login.
Then heading to the Connect to OpenClaw and copy the prompt.

If first time login and authenticate and you are done!

2. Composio npm package

Composio recently released their open claw plugin, this mean's, no config headache, simple one liner command does it all!

So, head to terminal and type:

openclaw plugins install @composio/openclaw-plugin

Once done, setup your api key, following the steps:

Log in at **dashboard.composio.dev.**
Choose your preferred client (OpenClaw, Claude Code, Cursor, etc.).
Copy your consumer key (ck_...).

In terminal run:

openclaw config set plugins.entries.composio.config.consumerKey "ck_your_key_here"

Finally restart the gateway:

openclaw gateway restart

All this does is setup the open claw configuration with consumer key in the Composio MCP.

Or alternatively, you can directly setup the mcp server, for more granular control.

3. Using MCP Porter

MCP Porter is OpenClaw way to use mcp-server and comes inbuild. You can activate by going to: OpenClaw Dashboard -> Skills -> Search MCP -> MCP Porter (Install)

Note: if it doesn't open, restart the OpenClaw server.

Once you do that:

→ Go to home folder where OpenClaw is installed: /home/username/.openclaw/workspace/config

→ Open the mcporter.json in any ide and paste the following & save:

{
  "mcpServers": {
    "composio": {
      "baseUrl": "url_from",
      "headers": {
        "x-api-key": "api_key"
      }
    }
  },
  "imports": []
}

The url and api key are the one from the pre-require step.

or if you want a standard input output (stdio) server setup you can use:

npm install -g composio-mcp

{
  "mcpServers": {
    "composio": {
      "command": "composio-mcp",
      "args": ["--api-key", "api_key"],
      "transport": "stdio"
    }
  }
}

npx mcporter call --stdio "npx @composio/mcp@latest setup https://backend.composio.dev/tool_router/<api-key>/mcp" <tool_name> <arg1>=<value1>

Now to make sure agent pick up the composio mcp servers perfectly you need to setup the skills file!

npx skills add https://github.com/composiohq/skills --skill composio --yes

Now you are all setup to experience OpenClaw seamlessly.

💡Fact: Though you can do all the steps in section through prompt in OpenClaw Dashboard (section 1), but it causes security concerns as as it stores logs that are accessible to other, if they have your agent id!

Summary

Tools like open-claw seem amazing at first glance but can easily become a nightmare if not handled right - especially around security.

The moment you hand broad permissions or API keys to an agent; you've opened a door you might forget, but it is even there. It doesn't know what's sensitive, it just acts.

That’s where tool like Composio sidesteps this quietly by handling scoped access and managed credentials under the hood, so the agent does its job without holding the master keys to everything.

What other approach you find safeguards your privacy and sensitive data, do share in comments!

Top 10 OpenClaw Skills to Take Your Productivity Up a Notch!

Developer Harsh — Thu, 05 Mar 2026 12:43:15 +0000

OpenClaw is growing fast and if you've used it for anything beyond general tasks, you've probably noticed the gap.

It handles most things, but specialized work like research, UI/UX design, writing, or reverse engineering? The output quality just isn't there.

That's the problem SKILLS solves!

It's a single file that plugs into OpenClaw and gives it deep, domain-specific context - purpose-built instructions for doing one thing exceptionally well. Better context in, better output out.

The catch? OpenClaw's own ClawdHub has hundreds of these skills, and roughly 80% are garbage or outright malicious. Finding the good ones takes time.

Last week I did that work and here's what's actually worth using.

TL DR;

OpenClaw skils are single-file plugins that give OpenClaw deep, domain-specific context to go from generic output to expert-level results.
80% of ClawHub skills are garbage or malicious, so vet carefully; the ones listed here are already filtered for quality (even though some show malignant, most are vetted by security teams).
Composio - One integration that unlocks 860+ external tools (GitHub, Slack, Gmail, etc.) so you can build full AI agents without touching auth pipelines.
Reverse Engineering - Turns OpenClaw into a network analyst that captures traffic, decodes binary protocols, and spits out clean parsers and docs.
Frontend Design - Forces OpenClaw past generic purple-gradient output into bold, production-grade UI with real aesthetic intent.
Self-Improving Agent - Logs errors, learnings, and preferences into memory so OpenClaw gets smarter and more personalized over time.
Eleven Labs Agent - Gives OpenClaw a real voice and a failsafe: if email or text fails, it literally calls someone instead.
N8N Workflow - Chat-driven control over your local N8N instance - trigger complex automations without subscriptions or a dashboard.
Exa Search - Replaces generic browsing with a developer-focused index pulling from actual docs, GitHub repos, and coding forums.
Vercel - Plain English commands that translate directly into Vercel CLI actions - deploy, rollback, debug, no terminal needed.
OpenAI Whisper - Runs Whisper locally so you get fast, accurate transcriptions without your audio ever hitting a third-party server.
Home Assistant - Natural language control over your entire smart home, fully local, zero cloud dependency.

How To Install Skills in Openclaw?

Before moving forward we need to load skills in openclaw, and here is how to do it in 2 way’s.

ClawdHub

Clawdhub is central repository offered by open claw community, to load skills. Follow these steps to get up and running.

Go to ClawHub and head to skills section.
Select the skills you want by filtering as per needs / directly searching for them and open its page.
Navigate down and copy the command given after verifying Security Scan says Benign for Openclaw (vvi)
Head to the terminal where open claw is installed and paste it. For me its docker and its the same skill I will install!

# installs clawhub
npx clawhub@latest install sonoscli

# or you can use github
git clone https://github.com/peterskoett/self-improving-agent.git ~/.openclaw/workspace/skills/self-improving-agent

Caution: Never install the calwdhub skills directly with clawdhub directly, without visiting the clawdhub website and verifying security

You can ensure it is active, by going to calwdbot dashboard and checking skills section!

Skills.sh

Skills.sh is a website, recently released by vercel to curate highly vetted skills. Here is how to install skills using it:

Head over to skills.sh (by vercel) and find the skill needed.
Open the page and install the same skill using npm: npx skills add <owner/repo>
Let’s go with same skills as above.

cd .openclaw
npx skills add https://github.com/charon-fan/agent-playbook --skill self-improving-agent

Select openclaw from the list
- Press space to select and enter to finalize.

Once done, verify by revisiting the dashboard’s skills section:

With this understanding, we are ready to explore all the plugins I found out to be good.

Spoiler: you already installed 1 of them!

Top 10 Skills to use with OpenClaw

1. Composio

This one personally I use the most and it genuinely delivers.

It gives OpenClaw access to 860+ external tools through a single integration framework, meaning you can build AI agents that talk to GitHub, Slack, Gmail, and hundreds of other services without writing a single custom authentication pipeline.

Whether you're building autonomous agents or traditional apps, this skill handles all the heavy lifting.

To install this skill,

in terminal navigate to /home/<username>/.openclaw/skills
and run npx skills add composiohq/skills
select Openclaw, rest keep default.

Once done you will see composio folder under skills section.

This is also a good example of how open claw keep their skills and what happens under the hood when you use clawdhub to install skills.

Use Cases:

Building interactive, chat-based AI agents that securely access external services like Gmail or Slack via isolated MCP sessions.
- prompt: "Create an agent that monitors my Gmail and summarizes unread emails every morning."
Developing multi-tenant SaaS applications that require programmatic execution of external tools and manual authentication management.
- prompt: "Set up a direct execution flow for managing GitHub repos across multiple user accounts."
Setting up event-driven automation workflows that listen for real-time triggers and process verified incoming webhooks.
- prompt: "Create a workflow that triggers whenever a new Stripe payment is received."

3. Self-Improving Agent

Clawdbot already has some self-improvement capability, this skill takes it to the next level.

It dynamically tracks interactions, logging errors, active learnings, and feature requests into a dedicated memory folder.

This gives the bot a structured layer of intelligence that makes it more accurate over time, not just responsive.

Can be dowloaded from clawdhub at Self-Improving-Agent - ClawHub

Use Cases:

Continuously logging errors to prevent the bot from repeating past mistakes
- prompt: "Remember this error and avoid it next time."
Storing user preferences and learnings for a tailored experience over time
- prompt: "Remember I prefer concise responses" or "Log this as a learning."

2. Reverse Engineering

Ever wanted to reverse engineer a tool, app, or web service to understand exactly how it communicates under the hood - this skill is built for that.

It turns OpenClaw into an elite network analyst, capable of capturing raw traffic, dissecting unknown protocols, and translating binary data into clean documentation and custom parsers.

Whether it's security research, debugging, or system interoperability, this skill gives you full visibility into any network communication.

Use with caution & you can install it at: Reverse Engineering

Use Cases:

Capturing and analyzing raw network traffic to uncover vulnerabilities or undocumented features in proprietary communication protocols.
- prompt: "Capture and analyze traffic from this app and identify any undocumented endpoints."
Developing custom Wireshark dissectors (Lua) and Python parsers to map out complex binary structures and fixed headers.
- prompt: “Write a Wireshark Lua dissector for this binary protocol sample."
Performing entropy analysis and TLS fingerprinting (JA3/JA3S) to identify encryption methods and extract hidden metadata.
- prompt: "Run entropy analysis on this packet capture and identify the encryption layer."

But use cases are infinite, for e.g my friend reverse engineered entire product to build it better.

OpenClaw can build frontend apps out of the box, but the output is generic at best - the usual Inter font, purple gradients, and safe layouts.

If you're a frontend developer or UI/UX designer, this skill is non-negotiable.

It forces OpenClaw into a master-level design mindset, demanding bold aesthetic direction, intentional typography, and production-grade interfaces before a single line of code is written.

You can install this skill at: frontend-design by anthropics/skills (yup its by anthropic!)

Use Cases:

Rapidly prototyping highly distinctive landing pages that immediately stand out from competitor templates.
- prompt: "Build me a landing page with a brutalist aesthetic for a SaaS product."
Translating abstract brand vibes into fully functional, production-ready frontend code
- prompt: "Design a site that feels like an editorial fashion magazine, dark and high contrast."
Breaking out of cookie-cutter design ruts by forcing unexpected layout choices and non-standard typography pairings
- prompt: "Redesign this hero section, avoid any standard layouts or default fonts."

and more!

4. Eleven Labs Agent

If you are into voice-ai and tooling / your job requires ai calling services, this skill is a game changer.

It integrates directly with the 11Labs CLI, giving OpenClaw an actual voice and bridging the gap between text-based AI operations and real-world audio interactions.

Most interesting is fail safe mechanism: if clawbot failed to send text message or email fails, the bot automatically pivots to making a real phone call instead.

You can install the skills from at ElevenLabs Agents - ClawHub . Make sure you have your Eleven Lab’s API Key

Use Cases:

Acting as a fallback to physically call people or businesses if text-based emails or messages fail to send
- prompt: "If the email fails, call them instead."
Automating voice-based tasks like making reservations or handling customer service inquiries on your behalf.
- prompt: "Call and book a table for 2 at 7pm" or "Call support and follow up on my order."
Generating voiced summaries or updates for hands-free productivity
- prompt: "Read out my task list for today" or "Give me a voice update on pending emails.

5. N8N Workflow

You've probably used N8N - and if so, you already know that running enterprise-level automations burns cash fast.

This skill connects OpenClaw directly to your N8N instance, letting you spin up, manage, and trigger complex multi-step workflows using cron jobs & plain chat

This means no expensive subscriptions, no manual dashboard, just automation on demand & best part - entire process runs on local version, so data remins private.

You can install it at: n8n workflow automation - ClawHub.

Use Cases:

Triggering an automated sequence to create and post LinkedIn updates the moment a new podcast goes live.
- prompt: "When a new podcast episode drops, draft and post a LinkedIn update automatically."
Setting up complex, multi-app workflows entirely through conversational commands
- prompt: "Create a workflow that saves every Gmail attachment to Dropbox and notifies me on Slack."
Automating repetitive data tasks like scraping, formatting, and sending weekly reports
- prompt:"Every Monday at 9am, pull last week's analytics and email me a summary."

6. Exa Search

OpenClaw supports browsing, but for technical work, general search just doesn't cut it as it surfaces SEO blogs over actual documentation.

Exa fixes that by connecting OpenClaw directly to a search index built for developers, pulling from GitHub repos, technical docs, and coding forums instead.

If you write code regularly, this is the skill that cuts hallucinations and gets you accurate answers fast.

You can install the skill at: Exa - ClawHub

You require an EXA_API_KEY while setup

Use Cases:

Pulling the most up-to-date coding documentation and API references for web development.
- prompt: "Find the latest React 19 docs on server components."
Searching the web specifically for highly technical programming solutions and developer resources.
- prompt: "Search Exa for the best open-source alternatives to Stripe's API."
Finding real-world code examples and GitHub repos for a specific implementation.
- prompt: "Find me a GitHub repo that implements JWT authentication in Node.js."

7. Vercel

If deploying sites to Vercel is second nature to you, this skill just makes it faster and automated.

It connects OpenClaw directly to the Vercel CLI, translating plain conversational commands into the exact terminal scripts needed to deploy, manage, and update your projects.

No manual terminal work required anymore

You can install this skill at: Vercel Platform - ClawHub

Use Cases:

Deploying new websites, applications, and web projects using simple natural language prompts.
- prompt*: "Deploy this project to Vercel."*
Managing cloud hosting environments and triggering project builds without typing complex terminal commands.
- prompt: "Trigger a new build for my production environment" or "Roll back to the last stable deployment."
Checking deployment status and debugging failed builds on the fly
- prompt: "Why did my last deployment fail?" or "Show me the build logs for my latest push."

8. OpenAI Whisper

If you're a developer and content creator, you already know how valuable accurate transcriptions are, and uploading sensitive audio to third-party services isn't always an option.

This skill runs OpenAI's Whisper model locally on your machine, giving you fast, accurate transcriptions without your audio ever leaving your system.

This means anyone can turn spoken word into text regularly. It requires an OpenAI API key and relies on a local installation.

You can install this skill at: Openai Whisper - ClawHub

Use Cases:

Transcribing audio and video files completely offline for maximum privacy
- prompt: "Transcribe this audio file locally."
Quickly converting meeting recordings or voice notes into highly accurate text documents
- prompt: "Convert this meeting recording to text" or "Transcribe my voice note and clean it up."
Generating subtitles or captions for video content without a paid tool
- prompt: just say "Transcribe this video and format the output as subtitles."

9. Home Assistant & Extras

Personally, I haven’t used it, but few of my friends say its game changing in home automation.

It connects OpenClaw directly to a local Home Assistant setup, letting you control your entire home through fluid natural language.

This means no rigid routines, no cloud dependency, no data leaving your network.

You can install it at: Home Assistant - ClawHub

Use Cases:

Controlling smart lights, locks, and appliances locally via natural language commands
- prompt: "Turn off all the lights in the living room" or "Lock the front door."
Creating dynamic, AI-driven home automation routines without complex coding
- prompt: "Every night at 10pm, dim the bedroom lights and lock all doors."
Checking and managing the status of all connected devices in one place
- prompt: "Which devices are currently on?" or "Show me everything that's active in the house right now."

Isn’t this one insane? Turning a conversational ai bot into a localized, privacy-first smart home hub.

This wraps up most of the skills I found useful, some extra includes:

Model Usage: Monitors and reports API token consumption and usage statistics across various AI providers.
WhatsApp CLI: Allows you to draft, approve, and send WhatsApp messages hands-free using natural language prompts.
Bird (Twitter/X): Interacts with X (formerly Twitter) to search for keywords, check feeds, and pull social data directly into the chat.
YouTube Summarizer: Extracts and summarizes YouTube video transcripts to help generate descriptions, headlines, and social copy.
GA4 Analysis: Connects to Google Analytics 4 to provide automated, natural language summaries of your website's traffic and performance data.
GNO: Acts as a local document search indexer that uses BM25 vector hybrid search to retrieve AI-generated answers from your personal files.

Summary

OpenClaw skills are plugins that add tools, knowledge, and workflows to enhance the capabilities of the OpenClaw AI agent. Here are some key points about OpenClaw skills:

Installation: Skills can be installed using the CLI, by editing files, or through ClawHub. You can browse and install skills with one command.
Types of Skills: OpenClaw skills can include tools for automating workflows, interacting with external services, and performing specialized tasks.
Community Skills: There are over 2,868 community-built skills available on ClawHub, organized by category for easier discovery.
Security: Always review a skill's SKILL.md and scripts before installing, as some skills may have security risks. For more detailed information, you can explore the OpenClaw Skills Directory.
Alternative: You can use skills.sh to find and load all the non-malignant skills, but make sure to check all the files.

However, installing all skills separately, calling the right tools, invoking right methods in cli are such a hassle.

Composio Skill simples that and provides you access to 860+ services without worrying about tool selection, tool calls and context rot.

So, install it once and keep using Openclaw as normal with superpowers.

10 top Claude Code plugins to use in 2026

Developer Harsh — Tue, 17 Feb 2026 10:06:44 +0000

If you're building MVPs or production-grade apps with Claude Code, plugin’s is your secret weapon.

Instead of Claude guessing based on its training data, plugins give it eyes and hands to interact with live documentation, real-time databases, and your entire DevOps stack.

But with over 1,000 servers in the ecosystem, choosing the right ones is a hassle. Here are the top 10 MCP plugins you can plug into Claude Code to get work done right away.

Summary

*Awesome Claude Plugins *(ComposioHQ): Curated plugin registry + tool router that turns Claude into a workflow orchestrator across many services.
Claude-Mem: Adds long-term memory so Claude can carry context and preferences across sessions.
Superpowers: Structured lifecycle planning + skills framework for brainstorming, TDD, debugging, and code review.
Local-Review: Parallel local diff code reviews (multiple agents) to catch issues before you commit.
Plannotator: Makes planning mode clearer with structured, annotated plans you can review and share.
Ralph Wiggum Plugin: Visual testing for apps (notably Swift) by driving the Xcode simulator to check how things look.
Shipyard: Superpowers-style lifecycle plus IaC validation and security auditing for more “production” workflows.
Dev-Browser Plugin: Lightweight, faster browsing/testing alternative to Playwright-style flows with lower context overhead.
TypeScript & Rust LSP Plugins: Runs real type checks via LSP to surface type/lint errors inside the Claude workflow.
Agent-Peer-Review: Let's have Claude and Codex critique each other’s work and escalate to web search tools when needed.

Top 10 Plugins for Claude Code

Here are the top plugins that enhance your Claude Code experience as a user.

1. Awesome Claude Plugins

Awesome Claude Plugins by ComposioHQ is a curated registry and toolkit that extends Claude Code’s native capabilities.

It provides a central hub for custom slash commands, specialized agents, automated hooks, and MCP (Model Context Protocol) servers.

By leveraging the Composio Tool Router, it transforms Claude from a code-writer into a workflow orchestrator capable of interacting with hundreds of external services.

Installation

Clone and run Claude with any connect-apps plugin (for easy setup)

git clone https://github.com/composio/awesome-claude-plugins.git
cd awesome-claude-plugins
claude --plugin-dir ./connect-apps

Then run the setup

/connect-apps:setup

It will ask for an API key. Paste your API key when asked. (Get a free key at platform.composio.dev)

If you are curious about the directory structure, you can check it out in the official repo.

In case you are wondering, why should you use the repository for plugins, here are the key features.

Key features

Supports both Python (FastMCP) and Node/TypeScript (MCP SDK) implementations.
Provides deep research and planning methodology for agent-centric design.
Emphasizes building for workflows, not just API endpoints.
Optimizes for limited context windows.
Includes actionable error message design patterns.
Implements systematic tool development with proper validation (Pydantic/Zod schemas).
Follows the MCP Protocol specification (2025-11-25 version).
Includes best practices for tool annotations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint).
Provides code quality review and refinement guidance.
Powered by composio tool router

Use Case

Creating a bridge between Claude and a proprietary or niche API using the latest MCP standards.
Building projects requiring multi-step actions, such as Read a Jira ticket → Debug code → Open a PR → Notify Slack.
Managing context for large codebases, where minimising token burn while still providing Claude with powerful external tools is important.

A Few Must Explore’s

mcp-builder: A comprehensive skill that guides you through designing and implementing high-quality, agent-optimised MCP servers.
connect-apps: Instantly links Claude to 500+ SaaS applications (GitHub, Slack, Gmail, Notion) to perform real-world actions directly from the CLI.
ship: A robust PR automation system that handles the entire pipeline, from linting and testing to review and production deployment, with one command.

Explore more at: Awesome Claude Plugins for Claude Code | Composio HQ

2. Claude Mem

Claude-Mem helps Claude remember context across sessions, reducing the need to re-explain their codebase and preferences each time.

Key Features

Captures and compresses Claude’s actions and injects relevant context into future sessions.
Uses SQLite and Chroma for hybrid search with vector embeddings.
Supports privacy by allowing you to exclude specific information from storage.

Use Cases

Managing large codebases where Claude needs to maintain context across multiple sessions.
Reducing the time spent on re-explaining project details.

Learn more at : [Calude-Mem | Github (https://github.com/thedotmack/claude-mem)

3. Superpowers

Superpowers combine lifecycle management with a skill framework, offering a comprehensive solution for development workflows.

Infact Claude learns brainstorming, subagent development with code review, debugging, TDD, and skill authoring through Superpowers itself

Key Features

Integrates with Get Stuff Done (GSD) structured lifecycle and phase-based planning.
Provides composable skills and Test-Driven Development (TDD) discipline.
Includes Infrastructure as Code (IaC), such as validation, security auditing, and code simplification.

Use Cases

Managing complex development projects with detailed planning and execution phases.
Ensuring code quality and security through automated checks.

Learn more at: Superpowers – Claude Plugin | Anthropic

4. Local-Review

Local-Review allows Claude to perform code reviews on uncommitted local changes, running multiple agents in parallel to provide thorough feedback.

Key Features

Runs 5 agents in parallel to conduct comprehensive code reviews.
Rates issues and only flags those scored 80 or above.
Works on local git diffs, making it useful for immediate feedback.

Use Cases

Conducting quick and thorough code reviews before committing changes.
Identifying potential issues and edge cases in your code.

Explore more at : Local Review

Note: Since this plugin runs 5 agents in parallel, cost might go up, so prepare to loosen your pocket

5. Plannotator

Plannotator enhances the planning mode in Claude Code by providing a structured way to manage and annotate plans.

Key Features

Improves the planning mode with detailed annotations.
Helps organise and manage complex project plans.

Use Cases

Detailed project planning and management.
Organising complex tasks and sub-tasks.
A UI for reviewing, sharing, and approve plan, similar to Google’s Antigravity’s artefacts

Explore more at Plannotator - Visual Plan Review for Claude Code

6. Ralph Wiggum Plugin

This one is quite famous, at least on the name front, as an insider joke in the software development community.

Essentially, this plugin is designed for visual testing, especially useful for developing Swift apps.

While standard testing (like the TDD we discussed) checks if the code "thinks" correctly, this plugin checks if the app "looks" correct.

It uses the Xcode MCP to bridge the gap between Claude and your running simulator.

Key Features

Conducts visual tests of the app using an Xcode MCP.
Ensures that the app meets specific criteria and behaves as expected.

Use Cases

Developing applications where visual testing is crucial.
Automating UI and functionality checks.

Explore more at: Ralph Loop – Claude Plugin | Anthropic

Note: It can be costly to use, as my friend shared , he wiped out all his quota while on 20$ plan in one single loop of Ralph Wingum.

7. Shipyard

Shipyard combines lifecycle management from GSD with the Superpowers skill framework, adding support for infrastructure-as-code and security.

Key Features

Supports IaC validation for Terraform, Ansible, Docker, Kubernetes, and CloudFormation.
Includes a dedicated auditor agent for security checks.
Simplifies code by catching cross-task duplication and AI-generated bloat.

Use Cases

Managing full development lifecycles with a focus on IaC and security.
Ensuring code quality and security in complex projects.

Explore more at: Shipyard | Claude Code

You can think of shipyard as an extension of superpowers but for enterprise

8. Dev-Browser Plugin

The Dev-Browser plugin is a faster alternative to the Playwright MCP, reducing context load per pass.

Key Features

Faster than Playwright MCP.
Reduces context load, improving performance.

Use Cases

Web development for when quick, efficient browsing is needed.
Reducing the computational load on Claude.

I use it for frontend testing & backend data validation.

You can explore more at: Dev Browser | Claude

9. Typescript & Rust LSP Plugins

The plugins allow Claude to run proper type checks for TypeScript and Rust code.

Key Features

Integrates with Language Server Protocol (LSP) for type checking.
Ensures code correctness and reduces errors.

Use Cases

Developing in Typescript or Rust, where type checking is essential.
Improving code quality and reducing debugging time.
My friend uses it to test for linting and type errors.

Explore more at:TypeScript LSP – Claude Plugin | Anthropic

A must have if developing apps in typescript / rust.

10. Agent-Peer-Review

This plugin provides peer reviews between Claude and Codex, allowing them to debate disagreements and escalate to external tools if needed.

Key Features:

Enables direct communication between Claude and Codex for peer reviews.

Supports escalation to Perplexity/WebSearch for additional context.

Use Cases:

Conducting comprehensive code reviews with multiple AI perspectives.
Reducing the manual effort of copying and pasting code reviews.
Benchmarking coding models across councils of models (Codex & Claude)

I felt this one was a joke till I tried. But it really gets work done!

I used it to validate Claude’s work using codex across varied perspectives on a research project code, and it helped me fix a critical bug that Claude missed during code generation.

Explore more at: Agent Peer Review | Claude

That concludes it, but it’s no use if you don’t follow these best practices for claude code!

Best Practices for Using Claude Code

To get the most out of Claude Code, consider these best practices:

Minimise the Provided Context: Keep the context concise to improve performance. Start fresh conversations for new topics and use tools like git diff to minimize the context.
Solve Problems Step by Step: Break down large problems into smaller, manageable steps. This helps Claude handle complex tasks more effectively.
Use Claude for Non-Coding Tasks: Claude is excellent for understanding codebases, brainstorming, and architectural discussions. Use it to prepare thoroughly before jumping into coding.
Leverage Git and GitHub CLI: Let Claude handle your Git and GitHub CLI tasks, such as committing, branching, pulling, and pushing.
Automate Code Reviews: Use plugins like Turingmind Claude Code Reviewer Skill to automate code reviews and catch subtle bugs and missed edge cases.
Use Subagents for Complex Tasks: For multi-step plans, use subagents to execute different parts of the task.
Be Strategic About Token Usage: Clear context after every user story and use the /compact command to manage token usage efficiently.
Design with Specificity: Provide detailed design specifications and use design systems like Shadcn UI to ensure consistent and high-quality output.
Use External Tools for UX/UI: Combine Claude Code with external design tools like Gemini or Uizard to generate UX/UI designs, then use Claude to implement them.
Continuous Learning and Adaptation: Stay up to date with the latest Claude Code features and practices. Regularly review and adjust your workflow to optimize performance.

Not all but, following even 1/3 of best practices can significantly improve your experience with Claude Code.
But here is the final takeaway from the blog!

Final Thoughts

Claude Code is a powerful tool that can significantly enhance your coding efficiency and quality.

By integrating the right plugins and following these best practices, you can unlock its full potential and streamline your development workflow.

Frequently Asked Questions

What are MCP plugins in Claude Code, and why do they matter?

MCP plugins (servers) let Claude Code interact with real systems like docs, repos, databases, browsers, and DevOps tools, so it can verify things and take actions instead of guessing.

Which plugins should I install first to get quick wins?

Start with a plugin hub/router (Awesome Claude Plugins), then add one for memory (Claude-Mem) and one for quality checks (Local-Review or TS/Rust LSP). After that, add planning/workflow (Superpowers or Shipyard) based on your needs.

Are these plugins safe to use with private code and credentials?

They can be, but treat them like any tool with access. Prefer least-privilege API keys, limit scopes, avoid storing secrets in prompts, and review what a plugin can read or write before enabling it.

How do I keep costs and token usage under control?

Keep context tight (use diffs, targeted files, and /compact), run tools only when needed, and be careful with multi-agent reviewers or visual testing loops since they can multiply usage fast.

How to Use MCP in OpenAI Code (IDE, CLI, App, Cloud)

Developer Harsh — Tue, 10 Feb 2026 08:59:12 +0000

The Rise of Codex

OpenAI's Codex has taken AI coding by storm, powering IDE, CLI, and cloud agents that write out code, fix bugs, and handle PRs at lightning speed.

Developers everywhere are buzzing about its game-changing potential for faster builds. Recently saw an X tweet claiming they will not go with Claude's code because Codex is better at planning first.

But here's the catch with MCP integrations: Codex shines when pulling real-time context from external tools, yet wiring up each MCP server for GitHub, docs, or databases one by one is a tedious config nightmare that kills momentum.

What if you could plug in one MCP server that instantly unlocks 500+ apps, auto-selecting the perfect tools and methods for any task?

Enter Rube, the universal MCP hub. In this short blog, let's see how you can use it to supercharge your OpenAI Codex workflow across IDE, CLI, and the cloud.

How to set up MCP for Codex

The benefit of Codex is that it can run in all 3 modes:

GUI Mode: You can uninstall the Codex extension in VS Code, Cursor, or Windsurf. It reads your workspace, edits code, and runs tasks right in your favourite IDE.
CLI Mode: Terminal fans can install Codex CLI via npm install -g @openai/codex, then run codex In their project for local agentic coding.
Cloud Mode: Power users can delegate heavy tasks to Codex Cloud from the IDE or GitHub (@codex tags), freeing them to focus while it handles builds remotely. This is a unique edge over rivals.
Codex App: The new Codex app. A very beautiful UI that's very intuitive to work with.

But to use rube, all requires a bit of setup, here is how to do it for all modes!

1. Set up MCP in Codex GUI Mode

I thought connecting remote MCP servers to the Codex extension was easy, but it's a major issue, an open one right now on GitHub.
So, here's the clean workaround I found to use MCP with extension:

Go to Rube, sign up/log in, or whatever MCP servers you want to use.
Head to Rube Chat → Use Rube → MCP URL → Generate Token. (You can use any other MCP URL)

Copy the token
Install the Codex extension for VS Code and log in.
Then: ⚙️ → MCP Settings → + Add servers → Streamable HTTP:
Put in the following details:
- Name: rube
- URL: https://rube.app/mcp
- Headers:
  - Key: Authorisation
  - Value: Bearer
Save → Refresh → Authenticate → Done!

To verify if mcp server is enabled or not, paste the following in the prompt box:

Do you have access to [mcp-server]? Tell me all the task it can perform.

If it fetches the result with all tasks it can do or mcp details, you are all set.

You can check out the config.toml file for same, by going to ⚙️ → MCP Settings → Open config.toml file.

Now let’s set up the same for CLI.

2. Set up MCP in Codex CLI Mode

Terminal lovers, in the codex, we have 2 ways to setup mcp in the codex CLI:

Config file - config.toml (manual, explicit)
CLI commands (faster, recommended)

However, I find the config file offers full control in a single file and feels native.

Here is how to use the config file approach:

Install the codex CLI using: npm i -g @openai/codex (Make sure you have npm install)
Initialise a project root directory. I used codex-test
Create a folder named codex using mkdir .

Inside it creates a new file called config.toml and paste the following text from below and save it!

[projects."/home/devloper_hs/codex-tests"]
trust_level = "untrusted"

[mcp_servers.rube]
enabled = true
url = "https://rube.app/mcp"

[mcp_servers.rube.http_headers]
Authorization = "Bearer <auth-token>"

Notes

Replace the project path with your actual absolute path
Replace <auth-token> with the token you already generated earlier
trust_level = "untrusted" is the safe default

But those tied to terminal commands you can use:

codex mcp login <server-name>

for streamable-http based mcp servers*. Make sure to authenticate!*

or stdio based mcp servers

codex mcp add <server-name> --env VAR1=VALUE1 --env VAR2=VALUE2 -- <stdio server-command>

Example:

codex mcp add context7 -- npx -y @upstash/context7-mcp

Next head to the root of the file and run codex, login and run /mcp

To ensure it uses the MCP server, you can use the following prompt validation flow:

I liked the fact that instead of giving me rouge output, its actually gave me steps to validate. Btw I already validated the gmail earlier.

Now is the time to set up MCP for the codex using cloud mode.

3. Set up MCP in Codex Cloud Mode

Codex allows delegating tasks to a cloud instance, letting developers focus on other tasks.

Sadly, this has been long planned but not shipped. The blockers being: secure tool proxying, credential forwarding, deterministic replays and more.

A smart approach is to use the MCP process locally, then delegate responses and the rest of the work to the cloud.

4. Set up MCP in the Codex App

Click on the Settings gear icon on the bottom left.
Go to MCP Servers. You’ll see some servers that you can authenticate and use.
Or, add server
Choose STDIO or Streamable HTTP
Add your MCP server
And you’re done.

So, with this, we are all set to look at a few use cases of Codex!

Use Cases of Codex + MCP

Codex is mainly meant for coding, but with Rube MCP it can handle a variety of tasks. Here are 3 use cases I like to use as a developer.

1. Organizing Old Project Commits into an Existing Sheet for Refresher

Integrations: Google Sheet + GitLab

Create a new googlesheet and add last 10 code activity summary (PRs, commits, stale branches) from my [project] GitHub and local repository. Also give me the sheet link at the last.

& here is the output:

[pr_agent.mp4]

This gives me a rough idea of where I left off and start from there. No more mundane checks.

But the use cases don’t stop here.

2. Creating Changelogs / Project Report on the fly

Integrations used: GitHub, Google Docs

Create a new Google Doc and generate a clean changelog report for my [project] GitHub repository using the all merged commits in anice formatted way and give me doc link.

& here is the output

[commit_agent.mp4]

This allows me to turn my project changelogs into a well-formatted Google Doc and send them the pdf / Doc. They can use it to verify the progress, ask for further clarification or suggest some changes

By far, I have shared productivity stuff; it's time for an actual development use case!

3. Extracting Design Tokens from Figma File

Integrations used: Figma

This one has been game changer for me.

To be frank, I am not good with frontend, so I take inspiration form figma designs. However, manually converting the design to code was a headache.

But now I fire up Codex and ask it to extract design tokens I can use to replicate the frontend in a similar style.

Analyze the Figma design file at https://www.figma.com/design/ZoE3NGZObwwNBr9Iyv8X9G/Shopping-Website -- Community -? node-id=2-
tokens), and generate a markdown file named design.md at root of project containing a professional design system reference.
Include token definitions, usage guidelines, naming conventions, and example mappings suitable for engineers to directly
implement in code.

Here’s the output

[design_token_extraction_agent.mp4]

Ofc, I make a few changes here and there before implementing, but this now codex + rube combo makes life so easier.

And here is a bonus one for content creators!

Turning Codex into your Content Creator Devlogs in Medium Blogs Draft

Integrations used: Google Docs, Notion

Many developers love writing devlogs (summaries of what they did) while building a product. But with Codex + mcp, you can analyse each dev log on a day-by-day basis and create a blog that you can then share with the world. Similar to how big companies.

Here is the prompt I used:

You are tasked with creating an SEO-optimized blog post from development logs for Medium publication.

**Requirements:**
1. Read the @devlog file content based on chronological order (earliest to latest based on days)
2. Transform technical devlogs into a narrative-driven blog post with personal storytelling
3. Use Rube MCP's googledocs tool to create and format the document
4. Follow this structure:
   - Engaging title with primary keyword
   - Compelling hook/introduction
   - Main body with 3-5 naturally flowing sections
   - Personal insights and lessons learned
   - Conclusion with takeaways
   - Call-to-action

**Writing Style:**
- First-person perspective ("I discovered...", "My journey with...")
- Story-driven narrative that connects technical milestones
- Natural transitions between sections (avoid forced segmentation)
- Balance technical detail with accessibility
- Include challenges, breakthroughs, and reflections

**SEO Optimization:**
- Include relevant keywords naturally in headers and content
- Use H2/H3 headings for structure
- Add meta description (150-160 characters)
- Include 3-5 tags for Medium
- Optimize readability (short paragraphs, varied sentence length)

**Formatting in Google Docs:**
- Bold for emphasis and subheadings
- Italics for technical terms or emphasis
- Bullet points for key takeaways
- Code blocks where appropriate
- Proper spacing between sections

Execute the task by:
1. Analyzing devlog files chronologically
2. Creating the narrative structure
3. Applying proper formatting
4. Writing the blog post with Rube MCP googledocs tool

Output the Google Docs URL when complete.

And here is the output it created:

[content_creator_agent.mp4]

By default, Codex doesn’t have access to Google Docs, but MCP can help with that. So, we let Codex handle the generation process, and rube handled the Google Docs.

In short, this process allows anyone to turn their weekly builds into a full-fledged blogpost or content worth sharing.

I hope you got an idea of what’s all possible.

Now let’s look at the final lesson!

Final Thoughts

Even with vibe coding pushing software development forward, most people still treat Codex/MCP like a magic box. That’s the actual problem.

These tools don’t work magically. They need clear, structured prompts to give good output. Most people don’t have that skill yet, so results fall apart.

That’s where tools like Rube help - by enforcing structure and combining prompts with real tool support, instead of guesswork.

Going forward, this becomes the new normal. Using these tools well won’t be optional.

So, don’t waste time. Go to rube.app, connect it with Codex, and start building or automating your work.

How to use Fix MCP issue in LangSmith Agent Builder to Build Specialized Agents

Developer Harsh — Tue, 20 Jan 2026 10:19:43 +0000

How to leverage the Model Context Protocol to give your LangChain agents production-grade tool access without manually piping toools

LangChain recently introduced LangSmith Agent Builder, a no-code tool to build agents with natural languages and it's making quite the buzz.

Instead of relying on the user to set up nodes and edges, it allows chat-based interactions, where the user just needs to define the goal, and the system generates the prompt, connects tools, and sets up triggers automatically.

It built on top of LangChain’s deep agent’s framework and supports planning, persistent memory, and multi-step tasks for complex workflow.

However, when it comes to tool’s I felt it pretty limited, even connecting mcp was not straightforward, I had to struggle a bit to use remote MCPs.

So, I did a manual digging and found the issues to both problems, and this blog covers the fix along with few use cases.

Let’s get started!

TL; DR

LangSmith Agent Builder lets you build AI agents through chat instead of wrestling with nodes and edges, but the MCP connection is secretly broken.
Rube MCP unlocks 900+ tools instantly-Gmail, Calendar, LinkedIn, Exa-without auth headaches or tool selection chaos once you apply the manual fix.
Email triage becomes autopilot when agents fetch unread Gmail, categorize by urgency, and send consolidated summaries without you lifting a finger.
Calendar briefings turn intelligent when agents pull today's schedule, research external contacts via LinkedIn, and email you a personalized day-ahead report.
LinkedIn candidate sourcing gets surgical precision as agents calibrate with 5 samples, refine criteria iteratively, then deliver 30 qualified profiles matching your exact requirements.

Set Up MCP Server in LangSmith Agent Builder

For demonstration, we will go with hosted Rube MCP server as it allows me to access 900+ tools without worrying about auth, tool selection, query management and tool calling orchestration.

Here is what to do:

Head over to Rube & Login / Create Account
In left side panel select Use Rube → MCP URL → Copy it!
Now head to LangSmith agent builder and Login / Create Account (important that you select no-code experience)
Within LangSmith Agent Builder, click ⚙️ Settings → MCP Servers → Add MCP Servers
In the new modal put
- name: rube,
- URL: https://mcp.notion.com/mcp,
- Select OAuth 2.1 & hit save.
After few seconds, a pop up will appear asking to verify, hit verify and you need to re-login to rube / the tool.

However, it’s not over yet, you can’t use the tool yet!

If you go now to agent builder workspace, select Create manually instead, you will only see default tools (probably a bug), so to fix it, you need to click on MCP → fill in same details and revalidate.

After few seconds you will see tools listed under the mcp server name you added, in our case it’s RUBE.

Rube MCP Server Showing Tools

NOTE: Though I used rube mcp server for demo, you can use any other using same technique, till they don’t fix the issue!

Now let’s see how mcp server work together with LangSmith Agent Builder to handle daily odd jobs.

How to Use MCP server with LangSmith Agent Builder

The process at Agent Builder is slightly different than rest of the tool you might have used!

It actually a single agent.md file behind the scenes, with addition of folders like tools and skills as needed.

When you create agent, these file changes in real time based on instructions and can later be reviewed.

However, the above complexity is hidden behind a chat interface that allow user to prompt what they want to build, and the system take care of the rest.

So, let’s use it for ease of understanding, by building 3 agents (easy, medium, complex).

1. Email Triage Agent

The 1st agent will be a simple one, use the agent to fetch all the emails and triage them into Important, General & Rubbish.

Put in the following prompt to in the chat window & hit enter.

Build a agent that uses Rube MCP to fetch only unread emails from Gmail. For each email, analyze the sender, subject, and content, then triage into exactly three labels: Important, General, Ignore based on urgency, relevance, and action required. After processing all unread emails, return a single consolidated summary with bullet points grouped by label, including sender, subject, and a one-line intent per email. Do not modify, reply, or archive emails. Output the summary only after the task fully completes.

Now the agent builder will ask you few clarifying questions:

Once you answer these, like I have done, it will combine metadata, toolbox, instructions and generate an agent overview.

Hit create and your agent is created just like that!

To test the agent, in the left chat window enter:

Triage my unread Gmail emails using and email me the summary

Result:

As can be seen, it calls the gmail tool via rube mcp we added and did the task for us!

Note: To keep things simple, I have kept the text in markdown (apparently no rendering support in Gmail). Feel free to optimize it further.

Next up let’s spin up an agent that fetches the calendar and other tools, generates a daily briefer and send it to gmail.

Enter the following prompt in the chat window:

You are a daily calendar assistant. Each morning, get today’s date (dd-mm-yyyy), fetch all events for the day, sort them by time and importance, and identify busy periods, gaps, and back-to-back meetings. Briefly research external meetings if needed using tavily_linkedin_search accessed via rube mcp. Send a concise email summary of the day via Gmail.

Ensure you add the TAVILY_API_KEY & GEMINI_API_KEY by selecting ⚙️ at top as well, for it work fine.

Now to test:

send me 21/01/2016 briefing please

Results:

As can be seen, it calls the rube calendar & Gmail tool via rube mcp we added and sent me a email. It seems I have a scheduled travel, so it wrote a customized message for me. (ignore markdowns)

3. LinkedIn Candidate Sourcing Agent

As for last agent, let’s make an agent that can filter out / source candidate from LinkedIn based on provided criteria.

We will use rube mcp to call exa-tool and pass in the inputs and let it handle the rest.

Paste the following prompt in chat window:

You are an expert LinkedIn candidate sourcing agent. When a user requests candidates, first gather role requirements (skills, seniority, location, constraints) and ask clarifying questions if needed. Begin with a calibration search of exactly 5 candidates using the Exa search protocol via Rube MCP, returning real LinkedIn profiles only (name, role, company, qualifications, LinkedIn URL). 

Never fabricate data. Ask for feedback and refine criteria iteratively until the user confirms alignment. Only after explicit confirmation, run a full-scale Exa search via Rube MCP (default 30 candidates), list candidates in chat. Exclude candidates already at the hiring company. Clearly state limitations if results are sparse. Prioritize precision, transparency, and iteration over volume.

Ensure you add EXA_API_KEY and GEMINI_API_KEY in ⚙️ at top. Also select Gemini 3.0 Model from Model Selector

Let’s test it out:

Source LinkedIn candidates for a Senior Backend Engineer. Focus on Python, Django, AWS, 5–8 years' experience, based in India.

Results:

Amazing it called the exa tool via rube mcp, we added earlier and showed potential candidate in chat based on criteria's.

This is just a glimpse of what is automations are possible with LangSmith Agent Builder & and rube mcp. Feel free to expand these base examples as per your liking and get rid of those boring mundane task.

Time to look at the final take!

Conclusion

LangSmith Agent Builder paired with Rube MCP turns complex agent workflows into effortless no-code magic, handling everything from email triage to candidate sourcing.

Though the toolset starts limited, a quick MCP server like rube unlocks 900+ tools, letting you automate daily mundane task with chat-based prompts.

So, connect Rube to LangSmith, drop in a goal like "build me a reseach agent…” add API keys, connect to tools/ mcp’s and watch it build, run, and deliver - while you reclaim your time for high-impact work.

Happy Automating.

FAQ

Q1: How do I fix LangSmith Agent Builder not showing MCP tools after connection?

A: Click "Create manually" in Agent Builder workspace, select MCP, re-enter server details and revalidate -tools will appear under your MCP server name after verification.

Q2: What is Rube MCP and why use it with LangSmith Agent Builder?

A: Rube MCP is a hosted server providing 900+ pre-authenticated tools (Gmail, Calendar, LinkedIn, Exa) that integrate with LangSmith through OAuth 2.1 without manual auth configuration.

Q3: Can LangSmith Agent Builder create agents without coding experience?

A: Yes, LangSmith uses chat-based prompts to auto-generate system prompts, connect tools, and build agents—no node setup required, built on LangChain's Deep Agents framework.

Q4: What agents can I build with LangSmith and Rube MCP integration?

A: You can build email triage agents, calendar briefing bots, LinkedIn candidate sourcing tools, and any automation combining 900+ tools through natural language instructions.

DEV Community: Developer Harsh

9 Ways to Cut Token Consumption in Claude Code

tldr;

3. Don't let one session run forever with /clear + /compact + handoffs

4. Keep CLAUDE.md minimal

5. Use plan mode before touching any code

6. Use bounded subagents for noisy exploration

7. Force surgical repo navigation

8. Lean on skills and plugins for progressive disclosure

9. Using Composio MCP and CLI

My actual Claude Code workflow

I Took Cursor Agents Out of the IDE and It Got Weirdly Powerful 🤯

A Primer On Cursor Agents SDK

How to Set Up Cursor Agents SDK

Building a Production Agent With Composio MCP + Cursor Agent SDK

Why Composio?

Setup Workspace

Set up Environment Variables

The Code

Run the agent

Final Thoughts

Building Streamable HTTP MCP Servers from Scratch using FastMCP in 2026

tl; dr

What is MCP

MCP Components in Nutshell

The Architecture

How The Components Work Together

Build Local Stremable HTTP MCP Servers

Prequires

Work Environment Setup

Writing Server Code

Test with MCP Inspector

Connect to Hosted Streamable HTTP MCP Server

Connect to Composio MCP Servers (Streamable HTTP )

Using HTTP Streamable MCP Servers for Advanced Use Case (Financial Agent)

Prerequisites

Set up Composio MCP in Claude

Set up Workspace for Agent

Run Financial Analyst Agent

Deployment Notes for Production MCP Servers

Conclusion

Top Marketing Skills For Claude Code, OpenClaw & Hermes

Quick Summary

Top 10 Marketing Skills

1. GEO / AEO SKILL - AI SEARCH OPTIMIZATION

2. SEO + GEO FULL STACK SKILL

3. PAID ADS AUDIT SKILL

4. FIRECRAWL WEB INTELLIGENCE SKILL

5. DESIGN SKILL

6. REMOTION VIDEO SKILL

7. MARKETING PAGE GENERATION SKILL - FRONTEND

8. CONTENT OPS SKILL

9. HUMANIZER SKILL - DE-SLOP YOUR CONTENT

Bonus Skills - A Toolbox for Marketing Teams

Final Thoughts

Building a Financial Agent That Actually Works: Composio MCP + Hermes

What is Hermes Agent

Securely Setup Hermes Agent

Add MCP using Composio CLI (Optional)

Building A Financial Analyst Agent

Best Agents SDK in 2026

Why This Comparison?

OpenAI Agents SDK

Core Primitives

Why Use It

Ease of Getting Started

Developer Experience

Example

Claude Agent SDK

Core Primitives

Why Use It

Ease of Getting Started

Production Readiness

Example

Google Agent Development Kit (ADK)

Core Primitives

Why Use It

Ease of Getting Started

Developer Experience

Example

3. Don't let one session run forever with `/clear` + `/compact` + `handoffs`

4. Keep `CLAUDE.md` minimal