Forem: Developer Harsh

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.

How to use OpenCode: A Practical Guide + Builds

Developer Harsh — Tue, 13 Jan 2026 19:04:51 +0000

OpenCode has recently gained significant popularity in the open-source space. It’s an alternative to Claude Code.

But what if I told you could 100x your Opencode experience with just one MCP? Yes, with Rube, that’s totally possible. But wait, what is possible?

After building a thousand managed MCP integrations and speaking with countless users, we found that while MCP is a force multiplier, it still has physical limitations. Adding even a single GitHub server will take 20k tokens from your LLM's context window; adding Jira/Linear, Supabase, etc., will essentially choke the models. There is nothing novel in it; most industry folks are already aware of this.

So, how do we solve this?

By exposing a few meta tools (Search, Planner, Bash, Remote Workbench, etc). When the agent searches for tools, the search tool fetches only relevant tools from Composio-managed apps, ensuring the LLM's context space remains clean.

For complex issues, it uses a remote workbench or a bash script to chain multiple tools together, and instead of dumping the large artefacts directly into the context, Rube stores them in a file system and fetches the results as needed.

There’s more to it: OAuth handling, healing loop when tool execution fails, and more.

Here in this blog post, I’ll walk you through how to set up Rube MCP with Opencode.

TL DR;

Rube MCP plugs into OpenCode once and instantly unlocks hundreds of tools without the annoying manual MCP wiring.
Automate code reviews and send off clean summaries straight to Gmail or Slack using Rube’s mail tools.
Backend setup becomes trivial when Rube creates and seeds Supabase databases with text instructions and LLM commands.
Turn project insights into polished X threads and auto-save them into Notion with a single prompt.
OpenCode + Rube turns repetitive dev work into background noise so you can actually focus on building.

Install OpenCode

Let’s start with installing OpenCode.

Head to the terminal and install it using:

npm i -g opencode-ai

or use for the latest:

npm i -g opencode-ai@latest

Once done, verify it by:

opencode

It will open the TUI like this:

Now let’s connect it with Rube MCP.

Connect OpenCode with Rube MCP

Connecting rube mcp with OpenCode is straightforward:

Go to the Rube MCP site.
Signup / Login
Head to Add Rube → MCP URL → Generate Token and copy it.
Create a new folder open-code and open it.
Inside, create a new file called opencode.json
Open it with File Explorer, nano/vim, and paste the following code.
- Replace the <api-token> with copied token and save it:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "rube_mcp": {
      "type": "remote",
      "url": "https://rube.app/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer <api-token>"
      }
    }
  }
}

Now open the OpenCode again and type /mcp and it will show:

You can even verify this using OpenCode:

Do you have access to Rube MCP?

If you get an answer like this, it means we are all set:

Note: if you are new to MCP, don't change anything. If new to rube, for first time it ask for OAuth for each tool.

Now let's see a few use cases of Rube in OpenCode.

1. Using OpenCode to automate Code Review & Update

For the 1st task, we will ask OpenCode to find bugs across all files in a code repository, prepare a report, and send it to Gmail. (can use Slack as well)

Paste the following prompt:

Act as an autonomous code auditor. Given access to a source code @ repository, recursively scan all files, detect bugs, vulnerabilities, logical errors, performance issues, and bad practices, classify them by severity, suggest concrete fixes, and generate a structured report (summary, critical issues, file-wise findings, recommendations). Use Rube MCP to handle the Gmail task and send the full report to devloper.hs2015@gmail.com. At the end, output a concise execution summary of all tasks completed. Prioritize real execution over explanation; keep results actionable and production-ready.

In simple terms, the prompt asks the LLM to review the codebase, identify bugs, generate a summary, and email it to the user. The output should include a summary and a link to email. And all this should be done using rube’s Gmail tool.

Yup, we don't have Gmail support in Antigravity, but rube helps here!

And here’s the Output it generated:

Note: you may need to login to Gmail, if using first time.

For simplicity, the report is kept short. Feel free to expand it using a format you prefer.

Now let’s look at the 2nd use case!

2. Using Rube MCP to handle Supabase Database for Apps

For the next task, let’s ask OpenCode to handle the database creation via Rube MCP for a vehicle parking management app.

Paste the following prompt:

Build a minimal Parking Management System using Python, Supabase, HTML, and CSS with a Google Material Minimal aesthetic.

Project Setup
Create a new folder named `vms` and build the entire application inside it.
Create a `.venv` using `python3` and activate it before installing dependencies.
Use Supabase project ID: `<supabase-project-id>`.

Phase 1: Database Setup (via rube_mcp)
Use rube_mcp to create database `parking-system` and models:
User(id, name, email, created_at)
Admin(id → User.id, role, created_at) [predefined]
ParkingLot(id, name, location, total_spots)
ParkingSpot(id, lot_id → ParkingLot.id, spot_number, is_available)
Reservation(id, user_id → User.id, spot_id → ParkingSpot.id, start_time, end_time, status)
Establish all relationships and seed: 1 Admin, 3 ParkingLots, 10–15 Spots per lot, 5–10 Users, 8–12 Reservations.

Constraints
All Supabase operations via rube_mcp, production-ready code, env vars for secrets, clean error handling.

In summary: prompt the LLM to create a parking system model and define the relationship, and then pull in mock data defined in Supabase’s student-db using crud api’s.

Yup, we don't have Supabase support in OpenCode, but rube helps here!

Here is the output:

Notice how OpenCode defined the task, and worked on it incrementally, while OpenCode + rube mcp handled the heavy lifting

Now let’s look at the final individual task, which we will do with OpenCode + Rube

3. Using Rube MCP to generate a Build Log-based Social Media Post for X

For the final task, we will ask OpenCode to draft us an X thread by analysing the entire project (handled by OpenCode) and save it to Notion (handled by rube mcp)
Here is the prompt:

Analyze the entire @vehicle-parking-app project to identify its key problems, milestones, and achievements. Then, write a 5-tweet engaging X(Twitter)thread using a problem–solution narrative. The first tweet should hook readers, and the last should include a call-to-action. Keep each tweet under 250 characters, separated with "1/". Use only bold or italic formatting (no headings or code). Save the final formatted thread to the Notion page at https://www.notion.so/appdev1/Project-Devlogs-2e3b43216e448044941ec4ea71ca30cc. Use rube_mcp for notion.

In essence, the prompt asks OpenCode to analyse the project, find its key problems, milestones and achievements, use them to generate an engaging X thread based on given instructions and save it to the given Notion sheet.
How it worked out for me:

The OpenCode didn’t just create the task:

It launched its subagents to focus on analysing the project
while it performs the notion page retrieval,
Then use the results of the subagent to generate the thread and
Add it into given Notion page

Pretty handy, isn’t it?

But so far, we have looked at individual use cases. OpenCode + rube combination can do more. Let’s give it a final challenge!

Capstone Task

For the final task, let’s ask rube to create an image tools webapp that has 3 -4 functionalities, similar to pinetools.com, but in Python, Flask, core web dev frameworks and most heavy lifting done by rube integrations for AI tools.

Here goes the prompt:

Build a simple MVP-level image creation web app as a new project named image-tools. 

Inside the project, first create and activate a Python 3 virtual environment (venv), then build the full application. 

Use Python (Flask) for the backend, SQLAlchemy for the local database, and HTML, CSS, and vanilla JavaScript for the frontend. 

The UI/UX should follow a Google-inspired minimalist design — clean, centered, and modern. 

The app will have four AI-powered tools: Post Complement Image Creation, Theme Change, Background Removal, and Prompt-Based Image Generation. 

All image creation features should use Google Gemini API through Rube MCP (gemini) integration, where clicking a tool’s button triggers Rube MCP in the backend to process the request and return results. 

Flask handles routing and data flow, while Rube manages all AI automation for scalable, real-time image generation.

Follow the best security practices.

In a nutshell, the prompt asks OpenCode to build an image editing tool that can use rube mcp to:

Generate complement image to the provided post
Change the theme of a given image (defaults)
Remove the background of the provided image
Generate an image based on a prompt

while keeping the UI*-UX* minimal and simple (google inspired)

Here is the output:

Not only did OpenCode make the website one-shot with the power of Opus 4.5, but it also handled the DB (SQLite), multiple tool integrations, state handling, Ruber MCP routing, and UI/UX.

This concludes our final build. Here are a few of my final thoughts on OpenCode + rube integrations.

Conclusion

With OpenCode and Rube, the repetitive task became child’s play, and the best part is that this same workflow can be incorporated into various domains.

Though OpenCode has been developed for the last 15 years, it packs some serious punch and with Rube MCP as a partner, the only limit is your imagination.

So, head to Rube MCP, connect it to OpenCode, pull up some PRD doc, give it to Claude opus 4.5 / Claude sonnet 3.5 / Gemini3 models with a kickass prompt, and let the tool do its thing while you focus on software/automation architecting part.

Happy Building.

FAQ

Q1. How do I integrate Rube MCP into OpenCode?

Answer: Generate a token from the Rube dashboard and paste the provided code directly into your opencode.json config.

Q2. How do I verify that Rube is successfully connected to OpenCode?

Answer: In OpenCode check the bottom or use /mcp command editor, in the popup, and confirm that the Rube tool appears in your active list.

Q3. Do I need to configure credentials for all 500+ tools manually?

Answer: No, you configure Rube once, and it dynamically handles connections, requiring only a one-time OAuth login the first time you use a specific tool.

Q4. Can Rube handle tasks for platforms not natively supported by Antigravity?

Answer: Absolutely; Rube acts as a bridge to fetch data and perform actions on external platforms like Figma, Supabase, and Gmail that the native IDE doesn't support yet.

Q5. How can I optimize the code generation quality for complex tasks like Figma conversions? Answer: Ensure you provide rich context, such as clearly naming Figma layers and color styles, so the model understands the specific structural requirements.

Function Calling With Google Gemini 3 - Google ADK & Google Genai

Developer Harsh — Mon, 29 Dec 2025 10:01:19 +0000

What is function calling in LLMs?

Large Language Models cannot access external systems such as APIs, databases, or SaaS apps independently; function calling is the pattern that enables them to do so safely.

Instead of returning only natural language, the model can decide to “call” a function by emitting a structured description of which tool to use and which parameters to pass.

You expose your internal or third‑party APIs to the model as functions, and the LLM chooses when and how to use them for tasks like sending emails, updating Sheets, scheduling events, or fetching live data such as weather and stock prices.

Irony is that, despite the name, the LLM does not execute code itself; it returns a structured functionCall An object that your application uses to trigger real API calls and then feed results back to the model.

TL;DR

Function calling enables LLMs to interact with external systems: Instead of returning only natural language, models emit structured functionCall objects that your app uses to trigger real API calls, then feed results back.
Gemini's function-calling loop is straightforward: Declare tool schemas → Gemini returns functionCall objects → your app executes them → send results back → Gemini synthesizes a final answer. This simple pattern powers all agentic workflows.
Native google-genai SDK requires manual work: You must write tool definitions, handle authentication, execute functions, and orchestrate the conversation loop yourself.
Composio abstracts the complexity: Provides 900+ pre-built integrations so you don't have to write tool schemas or handle auth for each API manually.
Tool Router MCP as a unified interface: Handles search, planning, authentication, and execution across thousands of Composio tools in one place—less thinking, more building.
Pair with Google ADK for production agents: ADK provides primitives for tools, routing, sessions, and web UIs. Combined with Composio's Tool Router, you get full-blown multi-agent applications without integration hell.

How does Gemini function calling work?

Gemini’s function-calling API follows a multi-step loop with fixed terminology and data structures.

You declare tools as functions:
- One defines tools with one or more function declarations (schemas), each with a name, description, and parameters, using an OpenAPI‑like JSON structure.
- These declarations tell Gemini which external capabilities are available and how to call them.
User sends a request with tools:
- The request includes the user’s prompt and the tools configuration, passed typically via GenerateContentConfig in the Python SDK.
- Gemini reads the prompt and the tool descriptions, then decides whether a function call is needed. Prompting is key here!
Gemini returns functionCall object:
- Instead of a final text answer, Gemini may respond with one or more functionCall objects in the candidate’s content.parts . (crucial)
- Each functionCall object specifies the function name and a JSON-compatible args object containing parameters that match the defined schema.
The app code executes the function(s)
- The backend inspects the response, extracts each functionCall, and invokes the corresponding function or external API with the provided args. (We got this from the Gemini)
- This is where one can handle authentication, validation, error handling, and any side effects, which are critical in production. Sadly, Genai SDK don’t provide support for the same.
You send tool results back to Gemini
- You pass the original conversation plus tool results, wrapped as function response parts, in another generate_content call.
- Gemini then uses this data to produce a final natural-language answer or further function calls.
- This step is primarily handled in the backend, so it is not shown to users. They feel like LLM is handling it.
- However, in most cases, developers have to pass the results and the original conversation. You can refer to the official Gemini docs to learn more.

In essence, the model proposes tool calls → the app executes them and passes conversation + tool results → the model synthesises results → new prompt & same repeats.

Surprisingly, this simple loop is the backbone of agentic workflows with any LLM!

Tool calling with Gemini

In the google-genai Python SDK, we work with a Client, FunctionDeclaration, and GenerateContentConfig to declare tools and read function_call parts in the response.

The steps are as follows.

The Steps

1. Install the library and set up the workspace

Let’s start by installing the SDK and configuring the client. Open your terminal and paste the following command to installthe generative AI package:

pip install -q -U google-genai

Next, create a new Python file and import the following:

from google import genai
from google.genai import types

client = genai.Client(api_key="YOUR_GEMINI_API_KEY") # can do it from .env also

Pretty self-explanatory, right

2. Initial request: user query + tool definitions

Now is the time to add the initial request & tool definition. Let’s go with the tool definition first!

get_weather_fn = types.FunctionDeclaration(
    name="get_weather",
    description="Get the current weather conditions for a specific location.",
    parameters={
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": (
                    "The city and state/country, e.g., 'San Francisco, CA' or 'London, UK'."
                ),
            }
        },
        "required": ["location"],
    },
)

get_stock_price_fn = types.FunctionDeclaration(
    name="get_stock_price",
    description="Get the current stock price for a given ticker symbol.",
    parameters={
        "type": "object",
        "properties": {
            "ticker_symbol": {
                "type": "string",
                "description": "The stock ticker symbol, e.g., 'GOOGL' or 'AMZN'.",
            }
        },
        "required": ["ticker_symbol"],
    },
)

Here we create two function schemas. For this, we used FunctionDeclaration from types class. Think of it as a wrapper over the tool details that Gemini expects.

Each FunctionDeclaration includes a name, description, and parameters JSON schema describing accepted arguments.

Now let’s add our query:

tool = types.Tool(function_declarations=[get_weather_fn, get_stock_price_fn])

user_prompt_content = types.Content(
    role="user",
    parts=[types.Part.from_text("What's the weather like in London?")],
)

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[user_prompt_content],
    config=types.GenerateContentConfig(tools=[tool]),
)

Key parts here are:

model: A Gemini model that supports function calling, such as gemini-2.0-flash.
contents: Conversation history as a list of Content objects; here it starts with a single user message.
tools: A list with one Tool that wraps multiple FunctionDeclaration objects. We covered this earlier

3. Gemini’s response: requesting tool use

As this is not a typical query, the model might use tools. In that case, it returns the response that contains a function_call in one of its parts. We need to extract that:

# simple code to extract the output of parts -> function call

candidate = response.candidates[0]
parts = candidate.content.parts

function_call_part = next(
    (p for p in parts if p.function_call is not None),
    None,
)

if function_call_part:
    fc = function_call_part.function_call
    print("Function name:", fc.name)
    print("Function args:", fc.args)

The extracted function_call should follow the schema as:

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "get_weather",
              "args": {
                "location": "London, UK"
              }
            }
          }
        ]
      }
    }
  ]
}

Important fields here are :

parts[].function_call.name: Name of the tool (e.g., "get_weather") that matches the schema declaration.
parts[].function_call.args: Object containing parameters Gemini inferred from the schema and user prompt.

In the last part of the Python code, we are extracting this only. You can check the output by running it yourself.

Note : Gemini can return multiple function call parts if it wants to use several tools in a single step.

4. Subsequent request: providing the tool result

Now that we have the request to execute the function, the app will execute it, and we need to pass the result to the model:

# define the tool (demo)
def get_weather(location: str) -> dict:
    # Mock api to mimic get_weather_results.
    return {
        "location": location,
        "temperature_c": 15,
        "condition": "mostly cloudy",
    }

# check if model actually returned a function_call part or not.
if function_call_part:
    fc = function_call_part.function_call
    tool_name = fc.name
    args = dict(fc.args)

        # conditionally run the tool 
        # (get_weather, get_stock_price)
    if tool_name == "get_weather":
        function_result = get_weather(args["location"])
    elif tool_name == "get_stock_price":
        # Implement get_stock_price here
        function_result = {"error": "get_stock_price not implemented"}
    else:
        function_result = {"error": f"Unknown function '{tool_name}'"}

        # wraps the tool call output & convert it to structured data
        # important for gemini to use
    function_response_part = types.Part.from_function_response(
        name=tool_name,
        response=function_result,
    )

    # defining model -> repersents model previous turn
    function_call_content = types.Content(
        role="model",
        parts=[function_call_part],
    )

        # define tool -> resperesent tool result to model's request 
    function_response_content = types.Content(
        role="tool",
        parts=[function_response_part],
    )

        # merge to pass tool result, prompt & conversation history.
        # also make model aware of tools being used.
    final_response = client.models.generate_content(
        model="gemini-2.5-flash",
        contents=[
            user_prompt_content,
            function_call_content,
            function_response_content,
        ],
        config=types.GenerateContentConfig(tools=[tool]),
    )

        # finally print the output - in natural language
    print(final_response.text)

Here:

Part.from_function_response wraps the tool output so Gemini can consume it as structured data, not just plain text.
role="tool" The content makes it clear this is a tool result, not another user or model message.
Gemini then reads history, uses the tool result, and generates a final natural-language reply (or possibly more tool calls).
Check it for yourself.

Now let’s try to use a tool called to concretize our understanding

Function Calling with Composio Tools

Composio provides access to 900+ tools, including Google Gemini support, so we can leverage it to get up to speed without worrying about manual tool write-ups and authentication. Let’s code one to understand better.

We start by installing composio packages:

!pip install google-genai composio-gemini composio

Then we import libraries and set up configs:

To get the Composio API key:

Head to Composio , either login/signup
Once in, go to settings → New Api Key → add name & hit create
Copy it somewhere safe, only visible once.
Also copy the user_id In the Debug info for support. We need this later on to authenticate composio tools.

import os
from google.colab import userdata
os.environ['COMPOSIO_API_KEY'] = userdata.get('COMPOSIO_API_KEY')

from composio import Composio
from composio_gemini import GeminiProvider
from google import genai
from google.genai import types

Then we create a composio and a Gemini client:

# Create composio client
composio = Composio(provider=GeminiProvider())

# Create google client
client = genai.Client()

Next, we add the composio user id and load tools, set up configs. For tools, we are using Composio’s DuckDuckGo search tool:

user_id = "e92b1112-5c68-4501-8af4-49af4199592f"

# Ge tools using the new SDK structure
tools = composio.tools.get(user_id, toolkits=["DUCKDUCKGO"])

# Create genai client config
config = types.GenerateContentConfig(tools=tools)

Then we create a chat and fire up a query to llm:

# Use the chat interface
chat = client.chats.create(model="gemini-2.5-flash", config=config)

response = chat.send_message("search about the latest info on OpenAI Code Red")

print(response)

Here is the output (middle part, usually hidden):

As can be seen, the response object consists of function_call key along with name, query and role. Time to extract the results.

Finally, we beautify the output:

# Check if there are candidates and content parts
if hasattr(response, 'candidates') and response.candidates:
    candidate = response.candidates[0]
    if hasattr(candidate, 'content') and candidate.content.parts:
        for part in candidate.content.parts:
            # Print only the text content if available
            if hasattr(part, 'text') and part.text:
                print(part.text)

Result:

Excellent, we got the response, and this is how Composio abstracts away manual tool writing; however, this doesn’t end here. What if you have to access multiple tools across multiple use cases?

This is where Composio’s tool routing comes into play. Let’s see it in action!

Function Calling with Composio Tool Router MCP with Google ADK

Google ADK (Agent Development Kit) is Google’s opinionated framework for building full-blown agents.

Unlike the raw Gemini SDK, ADK provides primitives for tools, routing, sessions, web UIs, and multi‑turn orchestration, making it far better suited for serious workloads such as production agents, dashboards, and complex automation flows.

But it’s limited in terms of tools, and for cross-application workflows, you’ll need to build integrations. However, creating these can take an eternity; if it’s not central to your core product, you can use Composio toolkits. We also have an even better abstraction, Tool Router.

Tool Router MCP is a unified interface that lets an agent search, plan, authenticate, and execute actions across thousands of Composio tools. This means less thinking, more building.

The Tool router MCP is super simple to use with Google ADK. Let’s see it in action.

We start by installing the required packages:

python3 -m venv .venv
source .venv/bin/activate
pip install google-adk composio composio_google

We then initialise the project with:

adk create composio_agent

And select:

root agent model as gemini-2.5-flash ,
model provider as Google AI and
Add the respective GOOGLE_API_KEY key when prompted. Get it from Google Studio.

This leaves us with a new directory with the name gmail_agent along with all essential files (.env, agent.py and init.py.

Next, we open gmail_agent/agent.py and add the code:

import os
import warnings

from composio import Composio
from composio_google import GoogleProvider
from dotenv import load_dotenv
from google.adk.agents.llm_agent import Agent
from google.adk.tools.mcp_tool.mcp_session_manager import \
    StreamableHTTPConnectionParams
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset

load_dotenv()

# This BaseAuthenticatedTool warning comes from ADK itself, it's nothing serious.
# Makes the entire UI, shit, so just ignore it here....
warnings.filterwarnings("ignore", message=".*BaseAuthenticatedTool.*")

GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
COMPOSIO_API_KEY = os.getenv("COMPOSIO_API_KEY")
COMPOSIO_USER_ID = os.getenv("COMPOSIO_USER_ID")

if not GOOGLE_API_KEY:
    raise ValueError("GOOGLE_API_KEY is not set in the environment.")
if not COMPOSIO_API_KEY:
    raise ValueError("COMPOSIO_API_KEY is not set in the environment.")
if not COMPOSIO_USER_ID:
    raise ValueError("COMPOSIO_USER_ID is not set in the environment.")

try:
    print("Initializing Composio client...")
    composio_client = Composio(api_key=COMPOSIO_API_KEY, provider=GoogleProvider())

    print("Creating Composio session...")
    composio_session = composio_client.experimental.tool_router.create_session(
        user_id=COMPOSIO_USER_ID,
        toolkits=["composio_search"],
    )

    COMPOSIO_MCP_URL = composio_session.url
    print(f"Composio MCP HTTP URL: {COMPOSIO_MCP_URL}")

    print("Creating Composio toolset for the agent...")
    composio_toolset = McpToolset(
        connection_params=StreamableHTTPConnectionParams(url=COMPOSIO_MCP_URL)
    )
    root_agent = Agent(
        model="gemini-2.5-pro",
        name="composio_agent",
        description="An agent that uses Composio tools to perform actions.",
        instruction=(
            "You are a helpful assistant connected to Composio. "
            "Use the available tools to answer user queries and perform actions. "
            "Execute the tools directly without asking for confirmation."
            "Just execute any tools that's required. no confirmation, at all. just run tools, directly when needed."
        ),
        tools=[composio_toolset],
    )
    print("\nAgent setup complete. You can now run this agent directly ;)")

except Exception as e:
    print(f"\nAn error occurred during agent setup: {e}")

and revert to .env file to add the environment variables:

GOOGLE_GENAI_USE_VERTEXAI=0
GOOGLE_API_KEY= your-gemini-api-key-from-build-studio
COMPOSIO_API_KEY = composio-api-key-from-dashboard
COMPOSIO_USER_ID = composio-user-id-from-dashboard

Then execute the code:

adk web .

Then run the prompt:

Find me top places to visit in Kerala. I have 10 days, 9-night trip and want to enjoy as much as I can.

Result:

Prompting Tips & Conclusion

While function calling is compelling, getting LLMs like Gemini to use tools as intended often reliably requires careful design and iteration.

If you find Gemini isn't calling functions when expected, calls the wrong function, or provides incorrect parameters, here are several strategies to improve performance:

Optimise tool definitions
- Write clear descriptions that explicitly state when to use each tool and optionally include short inline examples.
- Use intuitive, distinct function names and keep each tool focused on a narrow responsibility.
Refine schemas and prompts
- Use proper JSON schema types (string, number, boolean, object, array) plus enums to guide valid inputs strongly.
- In the user/system prompts, mention that the model should use tools when it needs external data or must perform actions.
Handle execution and errors carefully
- Implement robust error handling in your Python functions (network issues, invalid parameters, timeouts, etc.).
- Return informative error messages via function responses so Gemini can explain failures or retry gracefully.
Choose the right Gemini model and configuration
- Use more capable models like gemini-3.0-flash or later releases for better reasoning and tool selection.
- Consider using tool configuration options (e.g., forcing specific tools) when you need deterministic function calls.
Log, iterate, and test
- Log prompts, function calls, tool arguments, tool outputs, and final responses to debug misuses or missing parameters.
- Iterate on descriptions, schemas, and result formats based on real traces to steadily improve reliability.

So in the end I can only say:

With well-structured functions, clean schemas, and a robust Python handler loop, Gemini function calling lets you build powerful agents that combine strong reasoning with live access to APIs, databases, and platforms like Composio.

Frequently Asked Questions

Q1. What is the difference between function calling and tool use?

Function calling and tool use are the same concept with different terminology.

Function calling refers to the LLM's ability to output structured requests for specific functions, while tool use is a broader term that encompasses the entire pattern of exposing external capabilities (APIs, databases, services) to the model.

In practice, when an LLM performs function calling, it's engaging in tool use by selecting and invoking the appropriate tool for a given task.

Q2. Can Gemini execute functions directly, or do I need to implement the execution layer?

Gemini cannot execute functions directly. The model only returns a structured functionCall object that describes which function to call and what parameters to use.

Your application code must implement the execution layer parsing the function call, invoking the actual API or service, handling errors, and returning results back to the model.

This design keeps the LLM safe and sandboxed while giving you full control over what actions are actually performed.

Q3. How do I handle cases where Gemini calls the wrong function or provides incorrect parameters?

When Gemini selects the wrong function or provides bad parameters, start by improving your function definitions with clearer descriptions, more specific names, and stricter JSON schemas (use enums, proper types, and required fields).

Add explicit instructions in your system prompt about when to use each tool.

Implement validation and error handling in your execution layer to catch invalid inputs early, and return descriptive error messages that help Gemini understand what went wrong so it can retry or explain the issue to the user.

Q4. What is Composio's Tool Router MCP, and how does it simplify working with multiple tools?

Composio's Tool Router MCP (Model Context Protocol) is a unified interface that provides a single endpoint for searching, planning, authenticating, and executing actions across thousands of tools and integrations.

Instead of manually defining and managing dozens of individual function schemas, you connect to the Tool Router MCP, which dynamically exposes relevant tools based on your query.

This dramatically reduces boilerplate code and makes it easy to build agents that can seamlessly work across multiple platforms and services without writing custom integration code for each one.

Deepseek 3.2 Speciale vs Claude 4.5 Sonnet for agentic coding

Developer Harsh — Tue, 16 Dec 2025 12:33:38 +0000

DeepSeek recently released Deep Seek V3.2 Speciale - a reasoning-first model built for agents.

As a developer who uses both open- and closed-source models for his builds, I decided to test the new model (Deep Seek V3.2) with my most-used model, Claude Sonnet 4.5.

Also, during the building process, I used Rube MCP, a single server that gives you access to apps like GitHub, Linear, Supabase, etc and loads tools dynamically to avoid context bloat. This helps us get a good picture of the tool-calling ability of models and also gives us an excuse to use dog food for the product.

So, I coded a complete web app using the model to stress-test its capacity and found some fascinating insights.

This post covers my build process, prompts, exact builds and a few insights. Let’s dive in!

TL;DR.

I tested DeepSeek V3.2 and Claude Sonnet 4.5 on a full-stack feature-voting app.
DeepSeek V3.2 built parts of the app but stumbled on execution, speed, and reliability despite solid reasoning steps.
Claude Sonnet 4.5 powered through the whole build with cleaner planning and better tooling, just at a much higher cost.
Both models followed the workflow, but Claude handled ambiguity, testing, and end-to-end flow way more gracefully.
DeepSeek impressed with memory and tool usage but required manual fixes and felt noticeably slower.
Overall: DeepSeek is great for cost-efficient tinkering, Claude shines for dependable multi-step builds. So, pick based on your use case and cost.

App Overview

The app is the Team Feature Voting Board App., which internal product teams can use to:

Submit feature ideas.
Upvote/downvote features.
Comment on features.

While the board will:

Show vote counts, status, and basic metadata.
Filter by status (e.g. “Backlog”, “In Progress”, “Shipped”).
Prevent duplicate voting by the same user on the same feature.

For this, I will use Rube MCP as a provider, as it unlocks access to 500+ tools with one-click setup + automated tool selection, planning and execution.

Apart from that, for claude-sonnet-4.5 - I will go with Claude Code, and for Deep Seek V3.2 - I will use open code with open router as the model provider.

Testing Methodology

Used Claude 4.5 Sonnet with Claude Code and Deepseek 3.2 Speciale with Opencode.

I started from the basic flow:

Setting up app overview.
Writing the project brief + scope.
Creating Linear epic + tickets.
Designing UI frames in Figma.
Defining Supabase schema + migrations.
Designing API endpoints + interactions.
Planning frontend architecture + components.
Implementing backend logic (votes, comments, features).
Building frontend UI screens + state handling.
Creating GitHub Commit + PR.

For this, I wrote an instruction-based prompt and kept it in prompt.txt at the project level.

For both terminals, I also added a terminal prompt to add an overview of the project.

Terminal Prompt (same for both)

Follow @prompt.txt & Build me a kanban style fully functional Team Feature Voting Board App which can be used by internal product teams to: Submit feature ideas, upvote / downvote and comment on the feature. The board will show: vote count, status and basic metdata for each feature proposed (modal), allow to filter by status (backlog, pending, approved, rejected, inprogress, pending) and should prevent duplicate voting. Use rube_mcp to connect to use supabase as database, fetch figma file at:"url", commit after each step and update the tracked issues in Linear. Make ui look beautiful and ui-ux should be responsive for mobile.

You can check out the prompt I wrote in prompt.txt.

Results

Here is the output of both!

Deep Seek V3.2

Deep Seek V3.2 built a partially functional app, even with reference to the Figma file I provided, which has much of the functionality broken.
For ref: I had to manually fix the partial code for DB and RPA and update the NextJS and TypeScript config files.

It followed the following flow:

Went step by step,
fetched all the relevant tools using rube_mcp.
Remembered DB URLs, RLS rules, and, in fact, the DB ID itself.
Created backend and frontend with multiple ask prompts,
broke the high-level task into a to-do list and went one by one.
Relatively slow compared to Claude 4.5 Sonnet, with
no commits.

Overall, did the work partially & speed is a concern:

Cost: ~2$
Tokens: ~8.4M with auto-compact.
Time: ~ 1.45 hours - with additional prompt guidance.
Quality: Mid-level, partially functional.

Claude Sonnet 4.5

Claude's code built a fully functional app with a simple UI (as reference URL, Figma failed to fetch), which worked fine. It followed the following flow:

Planned API to fix rate limits.
Understood the provided URL is a Figma make file, not a design one & guided step by step to find the one.
Wrote a Python script internally to commit all the files in chunks.
Fetched Figma design files, failed and then recreated them own
One shot created the backend and the frontend.
Ran multiple tests after each new functionality, ensured it worked, then moved forward in the to-do list.
Got stuck with the final commit, so had to do it manually.

Overall, did the work well, but cost is a concern:

Cost: 10$
Tokens: ~14M tokens with auto compact enabled.
Time: ~ 50 minutes - one shot with multiple ask prompts.
Quality: Mid-level, fully functional. Considering it generated the frontend itself using the Figma design schema.

Final Thoughts

DeepSeek V3.2 and Claude Sonnet 4.5 are both general LLMs optimised for reasoning, coding, and tool/agent use, but their usage differs:

DeepSeek V3.2 - use when you need cost-efficient reasoning and open-source flexibility; usually for personal projects.
Sonnet 4.5 - use when you want stable multi-step planning, stronger execution, and enterprise-ready workflows and are ready to deal with cost.

But the best bet would be to combine both of them for your use case.

As for the final verdict, I would say:

With recent launches like GPT 4.5, Gemini 3, Sonnet 4.5, and DeepSeek V3.2, learning to pick the right models for the proper use cases has become more critical than ever.

Get started now!

Q&A

Q: Which model handled full-stack execution better?

A: Claude Sonnet 4.5 completed the entire app reliably, while DeepSeek V3.2 delivered only a partial build.
Q: Which model is more cost-efficient for long reasoning workflows?

A: DeepSeek V3.2 is far cheaper but noticeably slower and requires more manual fixes.
Q: When should you choose Claude over DeepSeek?

A: When you need stable multi-step planning, stronger tool use, and smoother end-to-end execution.
Q: Which model is better for flexible, open-source-friendly setups?

A: DeepSeek V3.2 shines when you want openness, lower cost, and reasoning-first workflows for personal builds.

The One MCP That Turns Antigravity Into a 500-Tool Powerhouse

Developer Harsh — Fri, 28 Nov 2025 12:53:18 +0000

Google recently released Gemini 3, Nano Banana Pro and its agentic IDE Antigravity, and it's exploding in popularity. AI, Builders & Business community are hyping it up like crazy.

But when it comes to tools, it's limited. Though one can add MCPs for use cases, it's hectic to connect every applications MCP servers manually

So, what if one has an MCP that you configure once, and it connects to 500+ products at once while intelligently figuring out which MCP tools and methods are needed?

Enter Rube, a universal MCP & in this short blog, let's see how you can use it to supercharge your AI-assisted development.

TL DR;

Rube MCP plugs into Antigravity once and instantly unlocks hundreds of tools without the annoying manual MCP wiring.
You can automate code reviews and send off clean summaries straight to Gmail / Slack using Rube’s mail tools.
Backend setup becomes trivial when Rube creates and seeds Supabase databases with text instructions and LLM commands.
Frontend devs can turn Figma wireframes into clean HTML/CSS by letting Rube fetch designs and Antigravity generate UI code.
Antigravity + Rube turns repetitive dev work into background noise so you can actually focus on building.

Connect Antigravity with Rube MCP

Before doing anything else, one needs to connect it once. Process is straightforward:

Go to Rube MCP site.
Signup / Login
Head to Add Rube → MCP URL → Generate Token
Copy the code to put in place of RUBE API KEY in mcp.json.
Head back to Antigravity, … dot in prompt editor → MCP -> Manage MCP Server → View raw config
Paste the command in mcp.json
Perform OAuth, wait till it completes
and boom, Rube added to the MCP list.

For verification, head to Manage MCP Servers, refresh and check the tool. It will look something like this:

Note: if you are new to MCP, don't change anything. If new to rube, for first time it ask for OAuth for each tool.

Now let's see a few use cases of Rube in Antigravity.

1. Using Rube MCP to automate Code Review & Update

Senior developer often analyse intern codebases, pointing out errors, summarising them and sending them to their Slack/email.

This can be a time-consuming, mundane & repetitive task. So, they can delegate it to Antigravity + Rube combo.

So here is a prompt to paste in the agent window prompt box (much like VS Code)

Prompt

Find the bugs in @agent.py @requirements.txt @__init__.py . 
Categorise them in low , medium high priority and create a short summary analysis with proper formating. 
Then using @mcp:rube_mcp: Send the summary to devloper.hs2015@gmail.com with title "Code Analysis Summary".

In simple words, the prompt asks the LLM to review the codebase, identify bugs, generate a summary, and send it as an email to the user. The output should include a summary and a mail link. And all this should be done using rube’s Gmail tool.

Yup, we don't have Gmail support in Antigravity, but rube helps here!

Now click > And wait till it's complete. If this is 1st time, rube will ask you to connect your Gmail account to send mail, but that's just OAuth for you.

Finally, it will come back with the draft/task it performed and an email link. Pretty transparent 😅

Here I am performing the same:

Note: You can even ask it to send to team slack, but I went with gmail, as this is just a demo.

Hopefully, now the intern will find the email and fix it all and send a pull request again :)

3. Using Rube MCP to handle Supabase Database for Apps

Backend developers often need to create different database models for different projects. This can be time-consuming, mundane and repetitive.

They can leverage Rube MCP to connect to Supabase, build the database in one shot, and use APIs to pull real-time information. Best part - no manual handling of pesky database issues, all handled by rube!

Here is a prompt to do so:

Build a minimal Student Grade CRUD application using Flask, Jinja, HTML, and CSS. The aesthetic should be "Google Material Minimal"—clean white backgrounds, subtle shadows, rounded corners, and excellent typography.

Phase 1: Database Setup (via rube_mcp)
Use the `rube_mcp` tool to interact with Supabase.
1. Create a table named `students` in the database `student-data`.
2. The schema should include: `id` (serial/int, primary key), `name` (text), `subject` (text), `grade` (int), and `last_updated` (timestamp).
3. Immediately seed this table with 5-10 realistic mock entries (e.g., "Alice Smith", "Mathematics", 92).

Phase 2: Flask Application
Create a single-file Flask app (or standard folder structure if preferred) that connects to this Supabase instance.
1. API/Routes:
   - GET `/`: Render the dashboard showing all students.
   - POST `/add`: Add a new student.
   - POST `/update/<id>`: Update a student's grade.
   - POST `/delete/<id>`: Remove a student.
2. UI/UX:
   - Use Jinja2 for templating.
   - Style using vanilla CSS (no external frameworks like Bootstrap).
   - Design: Center-aligned card layout. The table should look like a Google Docs file list or Google Classroom roster. Use soft gray borders (#e0e0e0) and the system font stack (Inter/Roboto/San Francisco).
   - Add a "Add Student" floating action button (FAB) or a clean top bar button.

Ensure the code is production-ready, handles database connections securely, and renders the frontend cleanly.

In summary: prompt the LLM to create a Google minimal style UI-UX-based CRUD app (for demo purposes) and pull in mock data defined in Supabase’s student-db using crud api’s. Here, the database was created using rube_mcp.
Yup, we don't have Supabase support in Antigravity, but rube helps here!.

Here is how it worked for me!

NOTE: For demo purposes, I have used a CRUD app example, but same flow can be expanded to complex project as well

Pro Tip

Always provide enough context for the LLM to perform the job as expected. For this example, this translates to adding:

db name - student-db
column name - id, name, subject, grade, last_updated
mock data - in tuple pairs.

With this power in hand, backend devs can create a robust and scalable database by just giving the right instructions!

Now off to the final use case of today!

3. Using Rube MCP to generate Frontend Code from Figma Mockups

Frontend developers often have to convert the Figma designs shared into webpages. They can leverage Composio’s Rube MCP to connect to Figma, fetch the designs, and generate the frontend code for them—best fact: no need to handle the conversion details; all done by rube.

Here is a prompt to do so!

Mockup (used for demo purposes only)

Prompt

Here is the figma file url https://www.figma.com/design/CHX6G247vkQFDYh84Qv9CS/Low-fi-Wireframe-Template--Community-?node-id=123-0&p=f&t=6OH8UhfkjgLRPLpE-0. 

Implement a blog based ui based on the given wireframe. Keep ui minimal and clean, similar to google (materialistic design). 

Only Tech stack to be used: HTML, CSS. Create the project in new folder called blogspace. I only need Mocup UI for client. 

Make sure to fetch the file using rube_mcp and then only start designing

In a nutshell, the prompt provides the LLM with a Figma URL and asks it to replicate the wireframe into an HTML blog page with CSS, all in the same folder.

Again, we don't have Figma support in Antigravity, but rube helps here!

This is how it turned out:

Pro Tip

For generating a complex frontend, follow these guidelines for optimized results:

Name the layers; include additional details, such as row and column numbers, in the layer names themselves. E.g memo-card-grid-row0-col0 (the leftmost corner).
Name the colour styles. E.g. ❌ #FFFFFF, ✔️ background-color-white
Name the file properly. Please don’t keep it generic.

These guidelines provide the model with enough context to generate the complex frontend architecture that developers are expected to deliver.

These were some use cases; the list is endless. But here is the final verdict!

In case of any errors, check out: Antigravity Coding Session

Conclusion

With Antigravity and Rube, the repetitive task became child’s play, and the best part is that this same workflow can be incorporated into various domains.

Though Antigravity is new, it packs some serious punch and with Rube MCP as a partner, the only limit is your imagination.

So, head to Rube MCP, connect it to Antigravity, pull up some PRD doc, give it to Gemini 3 / Nano Banana Pro with a kickass prompt, and let the tool do its thing while you focus on ideating and planning the part.

Happy Building.

FAQ

Q1. How do I integrate Rube MCP into Antigravity?

Answer: Generate a token from the Rube dashboard and paste the provided command directly into your Antigravity’s mcp.json raw config.

Q2. How do I verify that Rube is successfully connected to Antigravity?

Answer: Head to "Manage MCP Servers" in the editor, refresh the page, and confirm that the Rube tool appears in your active list.

Q3. Do I need to configure credentials for all 500+ tools manually?

Answer: No, you configure Rube once, and it dynamically handles connections, requiring only a one-time OAuth login the first time you use a specific tool.

Q4. Can Rube handle tasks for platforms not natively supported by Antigravity?

Answer: Absolutely; Rube acts as a bridge to fetch data and perform actions on external platforms like Figma, Supabase, and Gmail that the native IDE doesn't support yet.

Q5. How can I optimise the code generation quality for complex tasks like Figma conversions? Answer: Ensure you provide rich context, such as clearly naming Figma layers and colour styles, so the model understands the specific structural requirements.