Forem: Composio

How to Automate Your Slack Workspace with OpenClaw and Composio 🚀

Shrijal Acharya — Thu, 16 Apr 2026 15:19:55 +0000

Your team already lives in Slack. Code reviews, project updates and what not, it all happens there.

But the moment you need to file a GitHub issue, check a Linear ticket, or send a follow-up email, you leave Slack, do the thing, and come back. That context switch adds up.

What if your Slack workspace had an assistant that could do all of that for you, right in the thread. That too an isolated OpenClaw instance per user with admin control? 🤯

In this article, you'll learn how to automate an entire Slack team workspace that connects to your tools, takes actions, without you ever leaving Slack.

What's Covered

To quickly summarize what we’ll cover in this blog post, here’s what we’ll go through:

The idea behind building a Slack bot around OpenClaw.
How Composio lets each user connect their own tools.
How OpenClaw powers replies and tool usage.

These are a few things you'll understand, but there's so many others you'll learn along the way.

So, if you want to build a Slack-first (though not limited to) AI with personal tool access for each user, this will give you a solid starting point.

What we're building

We're building a Slack bot that brings OpenClaw into Slack.

💁 Not necessarily only for Slack, you can use pretty much the same setup for something like Discord with their SDK or your custom app. The idea remains the same.

Overall the idea is to use OpenClaw and give every user in a workspace their own single instance of it which powers the AI assistant.

That way, things are isolated per user and the admin can control/limit the toolkits (GitHub, Linear, etc.) the users get access to.

Each user can connect their own tools with Composio, so the bot can chat, and take actions using the tools they’ve authorized.

Here's a quick architecture.

Why Slack and how to create a Slack App?

No big reason to choose Slack, only because it supports slash commands, and it's mostly where people already work.

For this, we first need to have a Slack app, if you don't already have one, follow the quickstart guide to create one.

Once your app is created, enable Socket Mode so the bot can receive events without exposing a public webhook URL.

Then add at least these Bot Token Scopes:

app_mentions:read
chat:write
commands
im:history
im:read
users:read

Subscribe to these Bot Events:

app_mention
message.im

And create these Slash commands:

/connect: Use it something like /connect <toolkit>
/connections: User lists active connections
/help: Shows usage summary
/assign: Admin assigns an OpenClaw instance to a user
/add-mcp-config: Admin registers an MCP Config from platform.composio.dev
/add-auth-config: Admin links a toolkit to its Composio auth config
/list-mcp-configs: Admin lists all registered MCP Configs

Finally copy these values to your .env file, which you can find in the app settings:

SLACK_BOT_TOKEN=xoxb-...
SLACK_APP_TOKEN=xapp-...
SLACK_SIGNING_SECRET=...

Your SLACK_BOT_TOKEN is the bot token itself, SLACK_APP_TOKEN is the Socket Mode app level token and SLACK_SIGNING_SECRET is used by Slack to verify requests.

How to Set Up the Project

It's fairly simple to get this project up and running. Follow these steps:

git clone https://github.com/shricodev/saas-openclaw-slackbot.git
cd saas-openclaw-slackbot

Next, you install the dependencies:

npm install

Then set up the environment variables and run the development server:

# Slack
SLACK_BOT_TOKEN=xoxb-...
SLACK_APP_TOKEN=xapp-...
SLACK_SIGNING_SECRET=...

# Database
DATABASE_URL=...

# Composio api key (ak...) from https://platform.composio.dev
COMPOSIO_API_KEY="ak_..."

To get the Composio API key:

Log in at platform.composio.dev
Copy your API key (ak_..) from the Composio dashboard settings, then set it:

Configure Composio Dedicated MCP Server

In this section, we'll go through the process of creating a dedicated MCP server in Composio for each user.

First, head over to platform.composio.dev
Under the MCP Configs tab, create a Dedicated MCP Server. This lets you create MCP servers with specific apps and tools, which is exactly what we want.

Select all the toolkits you plan to assign for the user and create the MCP server.

For the External User ID, use the user's Slack user ID. To get someone's Slack user ID, head over to their profile, click the three dots, and select Copy Member ID.

Use that as the External User ID.

Keep note of the MCP config name and MCP config ID. You will need both when configuring the bot in Slack.

Upon successful creation, you'll find the URL:

You can copy this URL directly and add it to the OpenClaw config, which we’ll cover later in the Configure OpenClaw with Composio section. Alternatively, the bot can fetch it for you after you run the /assign slash command, which we’ll configure later.

You will also need the auth config ID tied to the tools you selected. In the MCP server, head over to the Manage Config tab and click Manage Auth Config. The auth config ID is listed on that page.

Keep note of this as well. You will need it when running /add-auth-config in Slack.

Core Components in the Application

We're not going to code everything from scratch as that'd be too long and impractical. Let's go over some of the core components in the project.

Before we start with the project core components, here's the project tech stack:

Slack Bolt - Official Slack bot framework. We use it with Socket Mode, which connects to Slack over a WebSocket without needing a public HTTP endpoint.
OpenClaw - The agent layer. Exposes an OpenAI-compatible API but acts as a full agentic gateway that plans, calls tools, and reasons over results.
Composio - The core of the project. Manages OAuth connections to external apps like GitHub, Linear, and Gmail, and exposes them to the agent via MCP.
TypeScript - Obvious choice over JavaScript as we get type safe code.
PostgreSQL + Prisma - Handles user records, connection status, and per-thread conversation history.

Bootstrapping the Bot

This is where everything starts. We initialize the Slack Bolt app with Socket Mode, register all handlers, and start the server.

// 👇 app.ts

const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  appToken: process.env.SLACK_APP_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET,
  socketMode: true,
});

registerMessageHandlers(app);
registerCommandHandlers(app);

(async () => {
  const port = Number(process.env.PORT) || 3000;
  await app.start(port);
  console.log(`Bot is running on port ${port} (socket mode)`);
})();

Instead of exposing a public HTTP endpoint for Slack to POST events to, Socket Mode opens a WebSocket connection. This means you can run the bot anywhere could be your local machine, a private server without a public URL.

If you've worked with bots before, this should be pretty straight-forward to understand. 👀

Handling User Messages

This is the brain of the bot. It handles both direct messages and @mentions in channels.

// 👇 message.handler.ts

async function handleUserMessage({
  message,
  client,
  text,
  channelId,
  threadTs,
}) {
  await saveMessage(
    slackUserId,
    slackTeamId,
    channelId,
    threadTs,
    "user",
    text,
  );

  const history = await getThreadHistory(
    slackUserId,
    slackTeamId,
    channelId,
    threadTs,
  );
  const priorHistory = history.slice(0, -1);

  const thinkingMsg = await client.chat.postMessage({
    channel: channelId,
    thread_ts: threadTs,
    text: "_Thinking..._",
  });

  const response = await generateResponse(
    openclawConfig.gatewayUrl,
    openclawConfig.gatewayToken,
    text,
    priorHistory,
    sessionKey,
  );

  await saveMessage(
    slackUserId,
    slackTeamId,
    channelId,
    threadTs,
    "assistant",
    response.content,
  );

  await client.chat.update({
    channel: channelId,
    ts: thinkingMsg.ts,
    text: response.content,
  });
}

There's a few things you might notice right up:

First, we store the user's message to the database before sending it to OpenClaw. But why? This way if the request fails, the history isn't broken. Similar to storing chat history in localhost when creating web chat applications.

I do not know if there’s a better way to handle this, but right now we just show a Thinking... message while the AI is generating the full response, and then replace it once the final output is ready.

A little hacky, maybe, but it gets the job done. There are probably better ways to handle this, like streaming the response, but for now the old-school approach works. 😋

Slash Commands

The bot exposes seven slash commands split into two groups: user-facing (/connect, /connections, /help) and admin-only (/assign, /add-mcp-config, /add-auth-config, /list-mcp-configs).

/connect

/connect <toolkit> starts an OAuth flow for a tool like GitHub or Gmail. But unlike the previous version where any user could connect any toolkit, now the bot checks three things before starting a connection:

Does this user have an MCP Config assigned?
Is the requested toolkit in that config?
Is there an auth config registered for this toolkit?

// 👇 command.handler.ts

app.command("/connect", async ({ command, ack, respond }) => {
  await ack();
  const toolkitSlug = command.text.trim().toLowerCase();
  const apiKey = getComposioApiKey();

  const assignment = await db.mcpConfigAssignment.findUnique({
    where: {
      slackUserId_slackTeamId: {
        slackUserId: command.user_id,
        slackTeamId: command.team_id,
      },
    },
    include: { mcpConfig: true },
  });

  if (!assignment) {
    await respond({
      response_type: "ephemeral",
      text: "You have not been assigned an MCP Config. Ask your admin to run `/assign`.",
    });
    return;
  }

  if (!assignment.mcpConfig.toolkitSlugs.includes(toolkitSlug)) {
    await respond({
      response_type: "ephemeral",
      text:
        "This toolkit is not available in your assigned config. " +
        "Your admin controls which toolkits you can access.",
    });
    return;
  }

  const toolkitAuth = await db.mcpToolkitAuth.findUnique({
    where: {
      slackTeamId_toolkitSlug: {
        slackTeamId: command.team_id,
        toolkitSlug,
      },
    },
  });

  // check if already connected
  const connectedToolkits = await getConnectedToolkits(apiKey, command.user_id);
  if (connectedToolkits.includes(toolkitSlug)) {
    await respond({
      response_type: "ephemeral",
      text: `You're already connected to *${toolkitSlug}*.`,
    });
    return;
  }

  const redirectUrl = await initiateConnection(
    apiKey,
    toolkitAuth.authConfigId,
    command.user_id,
  );

  await respond({
    response_type: "ephemeral",
    text: `Click here to connect *${toolkitSlug}*: ${redirectUrl}`,
  });
});

The response is only visible to the user who ran the command. That's intentional as OAuth URLs are personal and shouldn't be visible to the whole channel.

/assign

/assign is admin-only and lets admins assign a specific OpenClaw gateway to a user. It opens a Slack modal to collect the gateway URL, token and MCP config server ID.

// 👇 command.service.ts

app.command("/assign", async ({ command, ack, respond, client }) => {
  await ack();

  const userInfo = await client.users.info({ user: command.user_id });
  const isAdmin = userInfo.user?.is_admin || userInfo.user?.is_owner;

  if (!isAdmin) {
    await respond({
      response_type: "ephemeral",
      text: "Only workspace admins can assign OpenClaw instances.",
    });
    return;
  }

  await client.views.open({
    trigger_id: command.trigger_id,
    view: assignInstanceModal, // includes gateway URL, token, and MCP Config ID fields
  });
});

The user's MCP URL looks something like this: https://backend.composio.dev/v3/mcp/aaa-111/mcp?user_id=<slack_user_id>

It's the key because it's what connects the user's OpenClaw instance to the toolkits the admin selected for them.

/add-mcp-config and /add-auth-config

These two admin commands register the Composio resources in the bot's database. Both open modals.

/add-mcp-config registers an MCP Config by name and server ID:

// On modal submit:
await db.mcpConfig.create({
  data: {
    slackTeamId: teamId,
    composioServerId, // the UUID from the MCP URL
    name, // e.g. "Engineering"
    toolkitSlugs, // e.g. ["github", "linear"]
  },
});

/add-auth-config links a toolkit slug to its Composio auth config ID. This is what /connect uses to know which auth config to pass when initiating a connection:

// On modal submit:
await db.mcpToolkitAuth.upsert({
  where: {
    slackTeamId_toolkitSlug: { slackTeamId: teamId, toolkitSlug },
  },
  create: { slackTeamId: teamId, toolkitSlug, authConfigId },
  update: { authConfigId },
});

/list-mcp-configs

A simple admin command that lists all registered MCP Configs for the workspace:

"Engineering" - server: - toolkits: github, linear
"Sales" - server: - toolkits: gmail, notion

Sending Requests to OpenClaw

Up until this point we were working on the Slack side and a bit of Composio setup, but how do we actually send these messages to OpenClaw?

OpenClaw exposes an OpenAI-compatible /v1/chat/completions endpoint. Our service code wraps that with a proper system prompt, conversation history, and error handling. Nothing super unknown to most of you.

// 👇 openclaw.service.ts

export async function generateResponse(
  gatewayUrl: string,
  gatewayToken: string,
  userMessage: string,
  history: Array<{ role: string; content: string }>,
  sessionKey?: string,
): Promise<OpenClawResponse> {
  const systemPrompt: ChatMessage = {
    role: "system",
    content:
      "You are a helpful assistant in a Slack workspace. " +
      "You have access to the user's connected tools (GitHub, Linear, Gmail, etc.) through Composio. " +
      "The user's tools are already connected. Do not ask them to connect or authenticate. " +
      "Use the available Composio tools directly to answer questions. " +
      "Be concise. Format responses for Slack (use mrkdwn syntax).",
  };

  const messages: ChatMessage[] = [
    systemPrompt,
    ...history.map((m) => ({
      role: (m.role === "user" ? "user" : "assistant") as "user" | "assistant",
      content: m.content,
    })),
    { role: "user", content: userMessage },
  ];

  return sendToOpenClaw(gatewayUrl, gatewayToken, messages, sessionKey);
}

We also wrap the raw fetch in a custom OpenClawError class with error codes for timeouts, auth failures, and gateway errors. Preferred thing you do in a real-world codebase.

💡 Prefer something built-in like fetch over third-party tool like axios. Especially now after the recent compromise of axios which is used by hundreds and thousands of applications.

Connecting tools with Composio

You might be familiar working with Composio over the SDK @composio/core.

But with Composio, you can also directly talk to it's REST API. We now talk to the Composio REST API on backend.composio.dev using an API key from platform.composio.dev.

There are only three functions in the service, and each one does exactly what the name suggests 🤌

Check what a user has connected:

// 👇 composio.service.ts

export async function getConnectedToolkits(
  apiKey: string,
  slackUserId: string,
): Promise<string[]> {
  const url = `${COMPOSIO_API_BASE}/connected_accounts?user_id=${encodeURIComponent(slackUserId)}`;
  const res = await fetch(url, {
    method: "GET",
    headers: { "x-api-key": apiKey },
    signal: AbortSignal.timeout(30_000),
  });

  const data = await res.json();
  return data.items
    .filter((account) => account.status === "ACTIVE")
    .map((account) => account.toolkit.slug);
}

Initiate a new connection:

// 👇 composio.service.ts

export async function initiateConnection(
  apiKey: string,
  authConfigId: string,
  slackUserId: string,
): Promise<string> {
  const url = `${COMPOSIO_API_BASE}/connected_accounts`;
  const res = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": apiKey,
    },
    body: JSON.stringify({
      auth_config: { id: authConfigId },
      connection: { user_id: slackUserId },
    }),
    signal: AbortSignal.timeout(30_000),
  });

  const data = await res.json();
  return data.redirect_url;
}

Build the per-user MCP URL:

// 👇 composio.service.ts

export function getMcpUrl(
  composioServerId: string,
  slackUserId: string,
): string {
  return `https://backend.composio.dev/v3/mcp/${composioServerId}/mcp?user_id=${encodeURIComponent(slackUserId)}`;
}

This last one is the most important. There's no API call, it's pure URL construction. But this URL is what ties everything together: the composioServerId controls which toolkits are available, and
the user_id scopes which credentials are used. When /assign runs, it computes this URL and shows it to the admin so they can configure it in the user's OpenClaw instance.

Persisting Users and Conversation

Every Slack user that messages the bot gets a record in our database keyed on (slackUserId, slackTeamId) pair. This is a safety net, as the same Slack user ID could theoretically exist across different workspaces.

// 👇 slack-user.service.ts

export async function resolveSlackUser(
  slackUserId: string,
  slackTeamId: string,
) {
  const existing = await db.slackUser.findUnique({
    where: { slackUserId_slackTeamId: { slackUserId, slackTeamId } },
  });

  if (existing) return existing;

  return db.slackUser.create({
    data: {
      slackUserId,
      slackTeamId,
      composioEntityId: `slack_${slackTeamId}_${slackUserId}`,
    },
  });
}

Conversation history is stored per-thread using Slack's thread_ts (the timestamp of the first message in a thread) as the thread id. When the bot receives a message, it fetches the full thread history and passes it to OpenClaw, giving it the memory for the duration of that thread.

Configuration Setup

The bot requires per-user OpenClaw instances assigned by an admin. If a user hasn't been assigned an instance, they can't use any features. /connect, /connections and chat all require an assignment first.

Why not use shared instance?

By shared instance, I mean all the users share the same OpenClaw instance. So why not use it that way? That's how server is supposed to work?

There's a few reasons:

By default, OpenClaw is not designed to support multiple users connecting to the same gateway concurrently. In practice, which is likely to be the case for our use case.

This is already the main reason.

Also, in general, letting multiple users use the same instance with multiple connected accounts is not safe. A prompt injection by one user could access or destroy another user's data.

Even if there's safety measure (which I'm not aware of). Things could always go wrong. So better safe than sorry.

// 👇 lib/config.ts

export async function getUserOpenClawConfig(
  slackUserId: string,
  slackTeamId: string,
): Promise<OpenClawConfig> {
  const user = await db.slackUser.findUnique({
    where: { slackUserId_slackTeamId: { slackUserId, slackTeamId } },
    select: { openclawGatewayUrl: true, gatewayToken: true },
  });

  if (user?.openclawGatewayUrl && user?.gatewayToken) {
    return {
      gatewayUrl: user.openclawGatewayUrl,
      gatewayToken: user.gatewayToken,
    };
  }

  throw new Error(
    "No OpenClaw instance assigned. Ask your admin to run /assign.",
  );
}

No assignment, no access. The admin runs /assign for each user, providing their OpenClaw gateway URL, token, and MCP Config. Until that happens, the bot won't respond to that user.

Configure OpenClaw with Composio

Great, now the code part is done. There's one thing that's still left.

Now, the actual reason to build the bot i.e. to get tools access is not configured within OpenClaw which we do with Composio. It's the most easiest.

There's multiple ways to configure OpenClaw with Composio. There's standard ways you can find here.

But, we won't follow the standard way, as by default it uses consumer key, which is a way it's designed by default.

But we won't work with consumer key, we directly work with the MCP URL.

Go ahead and modify the OpenClaw config file which lives in the ~/.openclaw/openclaw.json with the following:

// rest of the config...

  "plugins": {
    "allow": [ "composio", "...rest"],
    "entries": {
      "telegram": {
        "enabled": true
      },
      "composio": {
        "enabled": true,
        "config": {
          "enabled": true,
          // put the MCP URL you receive after running /assign for a user.
          "mcpUrl": "..."
        }
      }
    },
  }

This sets up one instance for one user. But how do you about configuring multiple instances for multiple users?

How do you run it for multiple users?

This only configures one user in the entire workspace. But what about the rest?

There are a few ways:

1. Separate machine or VMs:

Each user's OpenClaw runs on a different machine. Each has its own ~/.openclaw/openclaw.json with its own MCP URL. This is the cleanest but most expensive.

2. Use named OpenClaw profiles:

OpenClaw ships with a --profile flag out of the box:

  --profile <name>     Use a named profile (isolates OPENCLAW_STATE_DIR/OPENCLAW_CONFIG_PATH under ~/.openclaw-<name>)

You can use a different profile per user. If you name each profile after the user, you get an isolated config for each one on the same machine. Most efficient.

For example:

openclaw --profile bob
openclaw --profile shrijal

3. Separate OS users on one machine:

Somewhat impractical. You'd run one OpenClaw instance per OS user, which means creating a separate system account for each person. Possible, but not a great approach.

There could be hundreds of other ways to do it. These are just the ones I could think of. Do your own research, and you’ll probably find others.

Slack Workflow

Run these commands in order as an admin before any user can start chatting.

/add-mcp-config

/add-auth-config

Assign each user their OpenClaw instance and MCP Config:

/assign

This gives you the user's scoped MCP URL. Configure it in their OpenClaw instance.

Once assigned, users run:

/connect <toolkit>

That's it. After connecting, they can DM the bot or @mention it in a channel.

Bot in Action

Here's a quick demo of the bot in action:

Conclusion

So yeah, that's the whole idea.

A Slack bot on top of OpenClaw, with Composio handling user tool connections, ends up being a really solid setup.

At this point, you’ve got a good idea of how this bot works with Slack, OpenClaw, and Composio.

We covered the main flow, how users connect their tools, how everything comes together inside Slack, and why assigning one OpenClaw instance per user helps keep things isolated.

It keeps the setup clean and gives you a bot that’s actually useful.

That's all for this one.

You can find the entire source code here: shricodev/saas-openclaw-slackbot

Shrijal AcharyaFollow

Full Stack SDE • Open-Source Contributor • Collaborator @Oppia • Mail for collaboration

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.

Top 10 Agent Skills Every Developer Should Install 🦾🛠️

Aakash R — Tue, 14 Apr 2026 08:04:56 +0000

AI agents are easy to demo, but getting them to work in real use is a different challenge.

Many setups can give good answers. Very few can finish a task, deal with errors, and keep track of what is going on across steps. To build that kind of agent, you need the right skills, such as using tools, managing memory, handling data, deploying your setup, and shaping how people use it.

This article covers the top 10 skills you need to build AI agents that actually work outside demos. Let’s get started!

1. Tool Integration with Composio

Composio helps your agent connect to external tools and APIs without dealing with complex setup. You can plug your agent into 1000+ tools like Gmail, Slack, GitHub, and more, and start executing real actions quickly.

Composio’s skill pack is built from real production use. It handles things that most agents get wrong, such as tool routing, session handling, authentication, and real-time events.

What the agent learns:

Tool Routing: Picking the right tool at the right time with proper session control
Authentication Flows: OAuth, API keys, auto vs manual auth, and connection handling
Session Management: Keeping user data isolated across multi-user setups
Webhook And Trigger Handling: Creating triggers, verifying requests, and managing lifecycle
Framework Integration: Working with LangChain, OpenAI Agents SDK, CrewAI, and Claude

Why it matters:

Without this skill, agents often mix up user sessions, break authentication, or call tools out of order. These issues may not show up in testing, but they cause serious failures in real use.

Install:

npx skills add composiohq/skills

This is the layer that turns your agent from a chatbot into a system that can actually get work done.

2. Frontend And Deployment Skills with Vercel

Vercel’s agent skills focus on building and deploying fast web apps using React and Next.js. It covers performance, UX, accessibility, and deployment best practices. This is a core skill set for any agent working on frontend or full-stack projects.

What the agent learns:

React And Next.js Performance: 40+ rules across multiple areas, from fixing render waterfalls to better caching patterns
Bundle Optimization: Reducing bundle size, using dynamic imports, and avoiding unnecessary client components
Server and Client Boundary: Sending only required data across components and avoiding over-serialization

Why it matters:

Frontend is where most agent-generated code breaks first. Code may work locally but fail in real-world use due to slow load times, poor structure, or bad UX. Without this skill, agents create apps that feel slow and unstable at scale.

Install:

npx skills add vercel-labs/agent-skills

3. Memory And Retrieval Skills with Weaviate

The Weaviate agent skill pack connects your agent to Weaviate’s infrastructure and fixes a common issue where agents guess outdated syntax or misuse search settings. It helps your agent build reliable semantic search and retrieval systems without errors.

What the agent learns:

Cluster Management: Inspecting schemas, creating collections, and managing metadata
Data Lifecycle: Importing and structuring CSV, JSON, and JSONL data with clean pipelines
Semantic Search: Choosing between keyword, semantic, and hybrid search with correct tuning
Agentic Search: Using natural language queries with built-in search and citation support
Advanced Retrieval: Working with multivector embeddings and combining BM25 with vector search
End-to-End Cookbooks: Building full RAG pipelines, chat systems, and deployable services

Why it matters:

Without this skill, agents often use outdated syntax, break search queries, or miss key setup steps. With it, an agent can set up a working search system, load data, and build a usable retrieval pipeline in minutes.

Install:

npx skills add weaviate/agent-skills

4. Model And ML Workflow Skills with Hugging Face

The Hugging Face agent skill pack connects your agent to the full Hugging Face ecosystem. It supports tools like Claude Code, Codex, Gemini CLI, and Cursor, and covers the complete ML workflow from datasets to training to deployment.

What the agent learns:

HF CLI: Managing models, datasets, repositories, and authentication using tokens
Dataset Workflows: Fetching data, filtering, searching, and downloading structured datasets
Model Training: Fine-tuning with SFT, DPO, GRPO, reward models, and handling deployment formats like GGUF
Gradio UIs: Building demos, chat interfaces, and interactive web apps
HF Jobs: Running GPU workloads, batch jobs, and tracking experiments
Transformers.js: Running models directly in the browser
Paper Publishing: Managing and linking research papers with models and datasets

Why it matters:

ML workflows include many connected steps where small mistakes can break results. Issues like wrong configs, poor batching, or missed auth steps can affect training and output quality. This skill helps agents follow correct patterns and produce reliable results across the workflow.

Install:

npx skills add huggingface/skills

5. Web Data And Automation Skills with Olostep

Olostep is a web scraping, crawling, and search API built for AI workflows. The Olostep setup works through MCP, so you can plug it into any MCP-compatible agent and grant it access to real-time web data.

What the agent learns:

Single URL Scraping: Extracting content from any page in Markdown, HTML, JSON, or plain text with JavaScript support
Batch Extraction: Processing up to 100,000 URLs in parallel with structured outputs
Site Crawling: Moving across pages to collect data from full websites
Structured Parsers: Using ready-made extractors for sources like Amazon, Google Search, and Maps
Natural Language Extraction: Asking for data in plain English and getting structured results
Web Agents: Automating steps like form filling, clicking, and navigation

Why it matters:

Web data is messy, inconsistent, and often blocked. Agents that try to scrape on their own spend time on retries, broken parsing, and access issues. Olostep handles these problems and returns clean, usable data in a single step.

6. Infrastructure And Edge Skills with Cloudflare

The Cloudflare agent skill pack covers a full platform for building, deploying, and running applications at the edge. It includes compute, storage, AI tools, networking, and security, all in one place. Skills load based on what your agent is working on, so there is no manual setup.

What the agent learns:

Workers And Pages: Deploying serverless functions and static sites with proper configs, routes, and secrets
Storage: Using KV, D1, and R2 based on the type of data and access pattern
Durable Objects: Managing stateful logic, coordination, and real-time features with WebSockets and storage
AI On The Edge: Running inference, vector search, and building stateful agents with built-in tools
MCP Server Creation: Creating remote MCP servers with tool access and OAuth support
Performance: Improving load times, caching responses, and fixing render-blocking issues
Security: Setting up WAF, handling DDoS protection, and applying Zero Trust patterns

Why it matters:

Cloudflare has many moving parts and strict runtime rules. Agents often use unsupported APIs, misconfigure storage, or deploy incorrectly. This skill helps the agent follow correct patterns and build systems that run reliably at the edge.

Install:

npx skills add cloudflare/skills

7. Monitoring And Debugging Skills with Sentry

The Sentry agent skill pack is based on real patterns used by the Sentry engineering team. It is not basic documentation. It reflects how production systems are monitored, debugged, and maintained at scale.

What the agent learns:

AGENTS.md Generation: Creating and updating agent docs that match real project structure
Claude Settings Auditing: Checking configs early to catch issues before they reach production
Sentry SDK Integration: Setting up error tracking, DSNs, source maps, and capturing useful context
Error Triage Patterns: Managing issues, grouping errors, setting alerts, and tracking releases
Observability For Agents: Making workflows traceable and easy to debug with distributed tracing

Why it matters:

Agents that ship code without monitoring create failures that are hard to detect and fix. This skill ensures your agent sets up tracking from the start, so errors are visible and easier to debug in real use.

Install:

npx skills add getsentry/skills

8. Backend And Database Skills with Supabase

The Supabase agent skill pack teaches your agent how to work with a full backend platform built on Postgres. It covers database, auth, storage, real-time features, and serverless functions. It is widely used in modern full-stack apps.

What the agent learns:

Postgres Best Practices: Writing efficient queries, using indexes, and avoiding slow patterns
Row Level Security: Defining access rules correctly to protect user data
Auth Patterns: Managing sessions, JWTs, OAuth, and protected routes
Storage: Handling file uploads, access control, and signed URLs
Edge Functions: Deploying serverless logic with proper configs and secrets
Realtime: Subscribing to changes, tracking presence, and managing connections
Client Libraries: Using Supabase SDKs with proper typing and error handling

Why it matters:

Supabase is used in many production apps, but small mistakes can cause serious issues. Poor queries can slow systems down, and incorrect access rules can expose data. This skill helps your agent follow correct patterns for both performance and security.

Install:

npx skills add supabase/skills

9. Payments And Billing Skills with Stripe

The Stripe agent skill pack teaches your agent how to build secure payment flows, manage subscriptions, and handle billing systems correctly. It covers the full lifecycle of payments and helps avoid costly mistakes.

What the agent learns:

Payment Intents: Creating and confirming payments, handling authentication flows, and avoiding duplicate charges
Subscriptions And Billing: Managing recurring payments, plan changes, trials, and cancellations
Webhook Handling: Verifying signatures, handling retries, and processing events in the correct order
Connect And Payouts: Routing payments in marketplace setups and handling transfers
Fraud Detection: Using risk signals and rules to prevent fraud without blocking valid users
Test Mode Patterns: Simulating real payment scenarios and testing failure cases
Error Handling: Managing declines, network issues, and retries without breaking the flow

Why it matters:

Payments are a critical part of any product. Small mistakes can lead to failed transactions, duplicate charges, or broken billing flows. This skill helps your agent follow safe and reliable patterns from the start.

Install:

npx skills add stripe/agent-toolkit

10. Video And Media Generation Skills with Remotion

The Remotion agent skill pack teaches your agent how to create videos using code. It uses React to build, structure, and render videos, which opens up a new type of output that most agents cannot handle.

What the agent learns:

Composition Model: Structuring videos using React components, sequences, and layouts
Timeline API: Controlling animation with frame-based logic and timing functions
Rendering Pipeline: Generating videos in formats like MP4, WebM, and GIF using the CLI
Audio And Video Assets: Adding and syncing audio, clips, and visual elements
Dynamic Content: Creating videos that change based on data or inputs
Walkthrough Generation: Producing product demos and app walkthrough videos from UI flows

Why it matters:

Video creation has mostly been manual and tool-heavy. This skill allows your agent to generate videos directly from code, enabling automation of content such as demos, reports, and visual stories.

Install:

npx skills add remotion-dev/remotion

Conclusion

The agent skills ecosystem is moving fast. Fine-tuning changes how an AI behaves and is costly to maintain. Agent skills are simple instruction files. You can update, swap, or share them at any time without changing the model.

Each skill pack in this list carries real engineering knowledge. It includes production patterns, lessons from real systems, and platform-specific practices, all in a form an agent can use right away.

Install the ones that match your stack. Your agents will spend less time making errors and more time getting work done.

Top 10 CLI Tools to Level-Up Claude Code

Shrijal Acharya — Mon, 06 Apr 2026 12:51:40 +0000

I've been using Claude Code more than any other AI agents recently.

And when it's the tool you use the most, it just makes sense to make that workflow as productive as possible.

A lot of the experience comes down to the small tools around it. The ones that help you search, navigate, review diffs, watch system usage, or just keep your workflow clean.

So this post is a simple list of the CLI tools I think pair really nicely with Claude Code.

There's an awesome repo with a curated collection of CLI tools for coding agents: awesome-agent-clis

What does "tools for Claude Code" actually mean?

Claude Code is already powerful on its own.

But it gets even better when you pair it with the right terminal tools, especially since you’re already working in the terminal.

I’m not talking about tools built specifically for Claude Code.

I mean the CLI tools that make the overall workflow smoother, faster, and easier to manage while Claude is working in your repo.

1. GitHub CLI

ℹ️ GitHub’s official CLI for working from the terminal.

What it is?

GitHub CLI is basically running GitHub from your terminal. You can create repos, check issues, review PRs, manage branches, and handle a bunch of GitHub workflow stuff without leaving your shell.

It can be as simple as:

gh repo create

for creating a new repository through an interactive prompt, which is one I use the most. And there are tons of other commands you can use.

Find all the others in the help window.

gh --help

Why use it with Claude Code?

This one probably will not be for everyone.

A lot of people do not want to give Claude access to their GitHub repos, and that is totally fair. But if you are comfortable with it, I honestly think it is one of the best tools to pair with Claude Code.

Or even if you do not want Claude directly using it, GitHub CLI is still great to have beside Claude Code since you can just run the commands yourself and keep moving without leaving the terminal.

2. Composio

ℹ️ An MCP server that connects Claude Code to hundreds of external apps.

What it is?

Composio is an MCP server you can add to Claude Code so it can work with 500+ apps.

You can find the guide on how to connect Composio with Claude Code here: Composio Universal CLI

Why use it with Claude Code?

The main way I use Composio with Claude Code is for email.

Say I am working on something and need to send a mail to someone.

Without this, I would usually have to stop, open my mail client, write the message, double check it, and send it myself.

With Composio set up inside Claude Code, I can just ask Claude to draft the email, or give it the content and the recipient, and it can handle the rest for me.

And maybe most importantly, no more spelling mistakes in your emails. 😃

That is the workflow I use the most.

Since you have 500+ app access, you can already imagine how many other things you could automate from there.

They recently added CLI support as well, which you can install here: Composio CLI

For development, Composio provides a playground with test users, execution logs, and real-time trigger streaming so you can iterate on agent behaviour locally before going to production.

3. ripgrep

ℹ️ The fastest way to search through a codebase from the terminal.

What it is?

It is a ridiculously fast search tool for the terminal.

It lets you search through files, code, and folders almost instantly.

If you have ever used grep, which I assume you have, it's a complete and faster replacement for that in real world repos.

A simple example:

rg "useEffect"

That will search for useEffect across your entire project and show you where it appears.

Why use it with Claude Code?

This is one of the first tools I'd install.

When working on a real world repo, you are constantly searching for things. Function names, config, and whatnot.

ripgrep basically makes that fast.

Even Claude Code defaults to using this tool when searching for things in its workflow. Overall, it is just super handy to have a quick way to move around the repo yourself without digging around manually.

4. tmux

ℹ️ A better way to manage terminal sessions.

What it is?

tmux lets you run multiple terminal sessions inside one terminal.

You can split panes, open multiple windows, switch between them quickly, and keep everything organized without opening a bunch of separate terminal tabs.

It might feel a little unnecessary at first. But once you get used to it, there is no way back.

Why use it with Claude Code?

For me, tmux is one of the most useful tools to pair with Claude Code, and it is actually what is running in my terminal right now as I work on this blog inside Neovim. 👀

I usually have Claude in a pane, with Neovim or a server running in one window, Lazygit in another, and then some extra panes for running commands.

If you use Neovim, it gets even better. You can have Claude open in one split and Neovim in another. As Claude makes changes, if you need to edit something, Neovim is right there. And for diffs or Git work, Lazygit is sitting in another window.

How cool is that?

You are not constantly jumping between tabs or losing track of what is running where.

5. FFmpeg

ℹ️ The go-to CLI tool for handling just about any media file.

What it is?

Honestly, this is one of the best tools I have added to my workflow recently.

FFmpeg is a command line tool for working with media files. You can use it to convert images from one format to another, like PNG to JPG, convert video formats, compress files, trim audio, and do all sorts of file processing.

It supports basically every format you can think of.

As developers, we end up doing this kind of stuff all the time. And having one tool that handles all of it from the terminal is just super handy.

💡 FUN FACT: Almost all the online media tools that you use on the internet, like online video compressors and similar stuff, are powered by FFmpeg under the hood.

Once you have it in your terminal, you really don't need to ever visit such sites.

Why use it with Claude Code?

The only catch is that FFmpeg commands are a little complex.

Even for a simple task, the syntax is just a little too much to understand.

Here's a quick command to crop a video file:

ffmpeg -i input.mp4 -vf "crop=1280:720:0:0" -c:a copy output.mp4

That is exactly where Claude Code becomes useful.

You can just describe what you want in plain English, and let Claude generate the right FFmpeg command for you.

6. Lazygit

ℹ️ A simple TUI for Git

What it is?

Lazygit is a terminal UI for Git.

It gives you a much nicer way to handle things like commits, branches, stashing, rebasing, and reviewing changes without typing every Git command manually.

You still stay in the terminal.

It just makes the whole Git workflow super easy, and you do not need to remember and type out any commands. Just knowing the concepts is enough.

Why use it with Claude Code?

This is one I always have open beside Claude Code.

When Claude makes a lot of changes in a bunch of files, Lazygit makes it easier to review everything, stage only what you want, and manage the overall Git workflow.

I usually keep Lazygit open in every session inside tmux, in its own window, so I can quickly jump there and handle Git stuff whenever I need to.

I will talk about tmux a bit later in the list, but this combo works really well.

7. btop

ℹ️ A much better way to monitor your system

What it is?

btop is a system monitor for the terminal.

It gives you a clean view of CPU, memory, disk, network, and running processes, all in one place.

There is also htop, which a lot of people already know and use. But personally, I prefer btop.

It just feels a bit more user friendly, and overall nicer and easier to filter down processes.

Why use it with Claude Code?

When you are doing a lot inside the terminal, especially with bigger repos, it is really useful to keep an eye on system usage.

That might be Claude, any processes it launches with your permission, local servers, or anything else running in the background.

btop gives you a quick way to see what is eating memory, what is using CPU, and whether your machine is starting to struggle, especially when you're using local models.

8. fzf

ℹ️ The backbone of fuzzy finding in the terminal

What it is?

I have probably been using this tool longer than any other in this list.

fzf is a command line fuzzy finder.

It lets you search and pick things interactively from the terminal.

That could be files, directories, Git branches, command history, processes, or really anything you can pipe into it.

If you haven't heard about this tool or have never used it, you are doing something wrong 😏.

A simple example:

find . -type f | fzf

This gives you a fuzzy searchable list of files in the current directory.

Why use it with Claude Code?

This is one of those tools that just makes terminal workflows feel faster.

Whether I am jumping between files, searching through something, or picking from a long list of options, fzf is usually involved somewhere. I have so many scripts built around fzf.

And when you are already spending a lot of time in the terminal with Claude Code, that kind of speed matters.

It is not really a Claude specific tool. It is one of the foundations that make working in the terminal and overall moving between things a lot better.

9. (Optional) LLMFit

ℹ️ Handy if you are experimenting with local or custom models alongside Claude Code.

What it is?

LLMFit is a CLI tool that scans your system hardware and tells you which local AI models you can run smoothly on your system.

If you are planning to run a local model, it is a nice way to avoid downloading something that your system will struggle with. Its whole purpose is to help match models to the machine you have.

Installing is as simple as:

pip install llmfit

Now, to scan your hardware against models, run this:

llmfit scan

and it will list out all the models with their metadata and performance scores based on your hardware.

Why use it with Claude Code?

This one is definitely more niche.

But if you are running Claude Code with a local or custom model setup, it can help you figure out what will run well on your machine before you waste time downloading the wrong model.

It is not something everyone will need, but for people who prefer the Claude Code agent and want to test newer local or custom models from other providers, this is an option as well.

You can find many guides on doing that. One that I referenced while trying it out is by Luong NGUYEN.

A few more nice ones

There are also a few other terminal tools I use a lot that I did not want to give a full section to, but they are still very much part of the overall workflow.

Things like fd, zoxide, eza, yazi, and bat all make the terminal feel nicer to work in.

Some help you move around directories faster. Some make listing files, previewing content, or moving around in the filesystem way better than the default.

I leave it up to you to research these tools.

None of these are Claude Code specific.

Ones I'd install first

If I had to set this up again from scratch, I’d probably start with ripgrep, GitHub CLI, tmux, and Lazygit.

That already covers a lot of the core workflow around Claude Code.

And separately, I’d also set up Composio.

It’s a bit different from the rest here. It’s not exactly just another CLI tool, but more of an MCP server. Really useful if you want to automate parts of your workflow and connect Claude to external tools in a cleaner way.

Final thoughts

You definitely do not need every tool in this list.

But a few of them can make working with Claude Code a lot smoother, especially once you start using it more seriously.

At the end of the day, it’s really just about making the workflow around Claude feel cleaner and easier to manage.

Shrijal AcharyaFollow

Full Stack SDE • Open-Source Contributor • Collaborator @Oppia • Mail for collaboration

Top OpenClaw Integrations to Connect Your Workflow in 2026

Aakash R — Mon, 06 Apr 2026 06:48:20 +0000

If you are using OpenClaw, you likely work with multiple tools, and switching between them can quickly disrupt the flow of work. Emails, conversations, code, files, and customer data often stay spread across different platforms, so work can start to feel a bit disconnected.

OpenClaw integrations bring these tools into a more connected flow. An update in one app can carry over to another, and information stays in sync as work moves forward. This cuts down repeated steps and keeps things moving without constant back-and-forth.

Let us look at some of the most useful OpenClaw integrations across key categories and how they fit into your workflow.

OpenClaw + Composio Integration

Before getting into specific integrations, it helps to understand how OpenClaw connects with all these tools.

Composio acts as the integration layer behind OpenClaw and supports 1000+ tools across communication, development, productivity, and more. Access to this large set of apps comes through a single system, so everything feels more connected from the start.

OpenClaw integrates with Composio to manage these connections in a consistent way, which keeps each integration structured similarly. Different setups or patterns across tools are reduced, so working across them feels more straightforward.

How to Connect OpenClaw with Composio

Getting OpenClaw connected with Composio takes a few simple steps. Once set up, integrations start working through a single flow.

Step 1: Install the Composio plugin

Install the Composio plugin inside OpenClaw to begin the setup.

openclaw plugins install @composio/openclaw-plugin

Step 2: Get your Composio API key

Step 3: Add the API key to OpenClaw

Set the API key in your OpenClaw configuration.

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

Step 4: Restart OpenClaw

Restart the OpenClaw gateway to apply the changes.

openclaw gateway restart

Step 5: Authenticate your tools

When you start using tools, OpenClaw prompts authentication through Composio. Connect the apps you need, and they become available in your workflows.

After completing these steps, OpenClaw can access and trigger actions across all connected tools through Composio, setting up the foundation for your integrations.

Next, we will look at some of the most useful OpenClaw integrations across key categories.

📧 Email and Communication

Communication tools are where most work naturally starts and continues through the day. Conversations, emails, and quick updates keep things moving, but they can also get scattered across different apps.

Connecting these tools with OpenClaw keeps everything closer to your workflow. Updates can move along with the work, and conversations stay tied to the actions they relate to, which keeps things clearer as tasks progress.

1. Gmail

Emails often mark the start of a task or follow-up. Connect Gmail to your workflow, and incoming messages can turn into tasks, updates, or next steps. Important threads stay linked to ongoing activities and keep everything visible and organized.

2. Slack

Many business decisions are made in Slack. When connected to OpenClaw using Composio, the messages can directly trigger actions across your workflow. Discussions in channels can update tasks, notify team members, or move work forward as conversations progress.

3. Microsoft Outlook

Outlook is a big part of daily communication for many teams, especially for ongoing conversations and follow-ups. Emails can tie into tasks and updates, which keep important interactions easy to follow as work moves ahead. OpenClaw keeps these updates aligned across your workflow.

4. Microsoft Teams

Teams is often where collaboration happens across chats and meetings. When linked with OpenClaw, updates and actions appear alongside conversations, keeping discussions and task progress closely connected.

🛠️ Dev Tools

Development work moves across code, issues, and collaboration. Keeping these tools aligned with OpenClaw keeps progress visible and reduces the need to manually track updates across platforms.

1. GitHub

OpenClaw brings GitHub activity into your workflow, where code changes, pull requests, and issues stay visible as work moves forward. Teams often switch between repositories and task trackers to stay updated.

Repository activity can be directly tied to tasks and progress, and development updates remain clear as changes occur.

2. GitLab

GitLab brings together code, pipelines, and collaboration in one space. OpenClaw brings build activity, commits, and issue updates into your workflow, and these updates shape how progress is tracked. These updates continue into your workflow through pipeline activity and code changes, and progress becomes easier to follow as work progresses.

3. Bitbucket

Bitbucket supports teams working across repositories and code reviews, where feedback and changes happen continuously. Tracking these alongside tasks can get scattered. Pull requests and repository updates can remain tied to your workflow to keep code changes and reviews visible as work progresses.

4. Jira

Jira is widely used for managing issues, sprints, and development tasks. Progress depends on how clearly updates across tickets are tracked.

Changes in ticket status and task updates can reflect across your workflow, and this helps maintain clear and aligned progress across tasks.

🎬 Media

Media and file management often sit across storage platforms, asset libraries, and content channels. Files move through different stages, such as creation, review, and publishing, and tracking these changes across tools can take extra effort.

1. TikTok

TikTok is used for creating and sharing short-form video content. Content updates, uploads, and engagement often tie closely to campaigns and timelines. OpenClaw connects video activity with your workflow, and updates around content and publishing stay aligned with ongoing tasks.

2. Instagram

Instagram plays a key role in visual content and social engagement. Posts, reels, and updates often connect with marketing and content planning. Content activity can reflect across your workflow, and updates around publishing and engagement stay aligned with your plans.

3. X (Twitter)

X is widely used for real-time updates and audience engagement. Posts, replies, and interactions often connect with campaigns and communication strategies.

Activity on X can tie into your workflow, and updates stay aligned with ongoing content and outreach efforts.

4. YouTube

YouTube is used to host and manage video content. Uploads, edits, and performance tracking all play a role in content workflows. Video activity can span your workflow and provide better visibility into publishing timelines and how content performs within your overall process.

⚙️ Productivity

Productivity tools sit at the center of planning, tracking, and organizing work. Tasks, notes, and schedules often live in separate apps, and aligning them can take extra effort.

1. Notion

Notion is widely used for notes, documentation, and planning. Teams rely on it to organize ideas, track tasks, and manage internal knowledge. OpenClaw brings updates from Notion into your workflow, so changes in pages, tasks, or databases stay visible alongside ongoing work. This gives better clarity on how plans connect to execution.

2. Trello

Trello organizes work through boards, lists, and cards. Tasks move across stages, and tracking these changes across tools can become fragmented. Card updates and task movements can reflect in your workflow, and progress across boards stays aligned with other activities and updates.

3. Asana

Asana helps teams manage tasks, deadlines, and project timelines. Work often spans multiple teams and requires clear visibility into progress.

Task updates, status changes, and assignments can connect to your workflow, and progress across projects becomes easier to follow.

4. Google Calendar

Google Calendar manages schedules, meetings, and reminders. Events often tie directly to tasks, deadlines, and team coordination.

Calendar events and updates can reflect in your workflow, and schedules stay aligned with tasks across teams.

💼 Sales and CRM

Sales and CRM tools manage leads, customer interactions, and deal progress. Data often moves across multiple stages, and tracking updates across tools can take extra effort.

1. Salesforce

Salesforce is widely used to manage leads, accounts, and sales pipelines. Teams rely on it to track interactions and move deals through different stages. OpenClaw brings updates from Salesforce into your workflow, and changes in leads, deal stages, or customer data stay visible alongside related tasks and activities.

2. HubSpot

HubSpot supports marketing, sales, and customer engagement on a single platform. Campaigns, leads, and interactions often closely connect to ongoing work.

Updates across contacts, deals, and campaigns can reflect in your workflow, and activity across teams stays aligned as progress develops.

3. Pipedrive

Pipedrive focuses on managing deals and tracking sales pipelines. Each stage of a deal requires visibility and timely updates.

Deal updates and activity can connect to your workflow, and progress across the pipeline becomes easier to track and follow.

4. Zoho Bigin

Zoho Bigin manages customer data, interactions, and sales processes across teams. Information often needs to stay aligned across multiple touchpoints.

Updates to leads, contacts, and deals can reflect in your workflow, and customer data remains aligned with ongoing tasks and activities.

Conclusion

Work rarely stays in one tool, and information continues to move across platforms as tasks progress. OpenClaw integrations through Composio connect these tools, so updates and actions stay aligned across systems. This reduces repeated effort and adds more structure to workflows.

Across communication, development, media, productivity, and sales, integrations improve visibility and coordination. The result is a simpler way to manage work, with tools working together in a connected flow.

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.

🚀 How to run a fully-autonomous company with OpenClaw 🦞

Shrijal Acharya — Thu, 02 Apr 2026 14:39:22 +0000

Imagine owning a company with just one human employee, and that too is yourself. The rest? All OpenClaw agents!

Before OpenClaw, that would have sounded completely silly, but with it, it's possible, really possible!

You can automate your entire company or simulate a fully functioning one with just OpenClaw and your VPS, Mac Mini, or local system for testing.

TL;DR

In this tutorial, you'll learn how to run an entire company using just yourself and a bunch of OpenClaw agents.

What you will learn: ✨

What OpenClaw is and how it works
Why storing API keys locally is a bad idea
Setting up Composio for secure OAuth-based integrations
Connecting your first app and getting agents up and running 🚀

Ready to become a one-person company? 👀

What's OpenClaw?

💁 I assume you already know what OpenClaw is. If not, why are you even here? Just kidding... The blog itself is completely beginner friendly. If you already have an idea of what OpenClaw is, just skip this section.

OpenClaw is a personal AI assistant you run on your own machine or a server you own. It is the thing that actually sits between your model provider (OpenAI, Anthropic, Kimi, etc.) and the stuff you want done, such as messaging, tools, files, and integrations, and this idea is what actually makes the one-person company possible.

Take this as a mental model:

Your LLM is the brain (thinks)
OpenClaw is the body (it can do things)
The Gateway is the receptionist (routes messages in and results out)

It provides the model with a runtime that can call tools, maintain state, and appear where you already chat (WhatsApp, Telegram, Slack, Discord, etc.). Now, that's just the gist. There's much more to understand. I assume you've already worked with it, so I'm not going any deeper than this in the intro.

For installation, visit the OpenClaw installation guide, and based on your distro and installation choice, install it on your machine.

If you just want it running quickly, do the normal installation. If you're even slightly paranoid (which you should be 😮‍💨), use Docker.

Also, make sure you set up a channel for easier chatting from your phone (preferably Telegram).

For help setting up a channel, ask OpenClaw itself. It knows itself better than anyone else on the internet.

💁 If you face issues like OpenClaw: access not configured when talking with the bot, make sure you run this command:

openclaw pairing approve <telegram/whatsapp/...> <pairing_code>

Just like that, now you have an agent listening on your channel. Message anything, and you should get a reply back.

From here onwards, I assume you already have OpenClaw running. To make sure everything is working, run this command:

openclaw health

If not, try running openclaw doctor, which helps debug your gateway or channel issues.

Run a whole company?

Yeah, in theory, you can actually automate or run an entire company. Can't guarantee the company will stand long, but with OpenClaw, it's now possible.

The only human in the process is going to be yourself. All your employees will be OpenClaw Agents.

As you can see, most day-to-day operations of running a company, such as sales, team meetings, and customer care, can be managed with OpenClaw Agents. And there are many more than just the ones in the image, of course. This is just a quick sketch to give you an idea.

Problem with "Just OpenClaw"

By default, OpenClaw works with API keys, and it stores them in a plain text file in the ~/.openclaw/ directory for all the services you use, such as Google, Gmail, and so on. This is not a very good practice if you're running this on your local machine. If using something like a VPS or the hyped Mac Mini, it's fine, but still, storing credentials in a local plain text file is never a good idea.

Especially if you're using smaller models, they are even more prone to prompt injections, and since OpenClaw has whole system access, it might wipe out your entire system without you doing anything.

What's actually gone wrong in the wild (already):

Malicious skills on ClawHub: researchers found hundreds to thousands of skills that were straight-up malware or had critical issues, including credential theft and prompt injection patterns.

Prompt injection turning into installs: there's been at least one high-profile incident where a prompt injection was used to push OpenClaw onto machines via an agent workflow.

For the above reasons, I recommend that you use some hosted service which in my case, Composio. It lets you authenticate using OAuth, which is the most secure option over pasting keys locally.

Connecting your first app

Now, it's time to create agents, but first, we need to set up or connect our first app from Composio.

The agents will mostly revolve around working with those applications from Composio.

1. Install Composio Plugin

Composio's OpenClaw plugin connects OpenClaw to Composio's MCP endpoint and exposes third-party tools (GitHub, Gmail, Slack, Notion, etc.) through that layer.

openclaw plugins install @composio/openclaw-plugin

2. Composio Plugin Setup

Log in at dashboard.composio.dev
Choose OpenClaw as the client.
Copy your consumer key (ck_...) from the Composio dashboard settings, then set it:

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

Now, it's a good idea to restart the gateway:

openclaw gateway restart

3. Verify the plugin loaded

openclaw plugins list
openclaw logs --follow

You're looking for something like "Composio loaded" and a "tools registered" message.

If the plugin is "loaded", it means you can now successfully access Composio.

Here's how it works:

The plugin connects to Composio's MCP server at https://connect.composio.dev/mcp and registers all available tools directly into the OpenClaw agent. Tools are called by name — no extra search or execute steps needed.

If a tool returns an auth error, the agent will prompt you to connect that toolkit at dashboard.composio.dev.

Here's how the configuration looks:

{
  "plugins": {
    "entries": {
      "composio": {
        "enabled": true,
        "config": {
          "consumerKey": "ck_your_key_here"
        }
      }
    }
  }
}

You can configure the following options directly from the config file:

enabled: enable or disable the plugin
consumerKey: your Composio consumer key
mcpUrl: the MCP server URL. By default, it's https://connect.composio.dev/mcp

Previously, you had to configure API keys per integration, but with Composio you don't have to worry about any of that. Just make sure not to leak the consumer key that we generated.

And it's that simple. Everything works out of the box just as you would use any other OpenClaw plugin!

Now, to test if it works, head over to the Control UI chat and send a message, something like:

"List the Composio tools you have available."

If it asks you to connect the tools, head over to dashboard.composio.dev and connect each of the tools you require. It's as simple as clicking Connect.

All the integrations you use are OAuth-hosted, and only the tools you connect will be available to OpenClaw. Nothing more than that.

Setting up a Multi-Agent Team

The idea is pretty clear. Since one single agent wouldn't be enough to handle all sorts of company requirements due to context window limitations, you could have multiple sub-agents for multiple task types.

Say, one agent AgentA handles marketing, AgentB handles business analysis, AgentC handles something else.

Each agent has a distinct role, personality, and model optimized for its use case — say, for business analysis, you'd want a more research-oriented model like GPT-5.2.

And how do you create them? It's simple, just chat with OpenClaw itself, either in the chat window or your configured channel.

Example:

Please create a new agent called **Shri**. This agent should be capable of handling tasks such as reading and composing emails, and scheduling Google Meet sessions.

For the model, use **Claude Sonnet 4.6** (`claude-sonnet-4-6`).

Please ensure that the existing main agent remains untouched and unchanged.

And it will create a new agent, which you can view in the Agents tab in the OpenClaw dashboard or by running /agents in the OpenClaw TUI.

Similarly, do it for all your different work types. Create a separate agent for each type of work.

The main agent can then delegate work to those specialized agents, each handling one specific task type, which improves response quality because one agent is handling one type of work instead of everything at once.

💡 TIP: This also helps you reduce model usage costs, as you can assign more reasoning-heavy models to complex tasks and smaller, cheaper models to simpler ones.

What's Missing?

Everything seems good, but there's one thing missing... autonomy.

You still have to message OpenClaw manually to get things done, which isn't ideal when you're planning on using it as an AI employee.

There are two ways to achieve this:

1. If you're a little technical

You must be familiar with cron jobs and their syntax. If so, this is a way to do it directly from the CLI outside of OpenClaw.

Run the following command:

openclaw cron add --schedule "<cron_syntax>" --message "<prompt>"

Say you want it running every single day at 8 AM:

openclaw cron add --schedule "0 9 * * *" --message "<prompt>"

2. If you're not technical

Similar to how we used a prompt to create a new agent, all you need to do is write a prompt:

Every morning at 9 AM, send me the top news of the day. Also scan my Google Calendar for the day, identify each attendee and their company. Send me two different messages on Telegram: one with the news summary and one with the meeting details.

Use the relevant Agent you have for each purpose.

💁 There's also a similar concept called Heartbeat, which is another approach for scheduling tasks in OpenClaw. You can check it out here: OpenClaw Heartbeat

Workflow Demo

Okay, time for a demo.

Showing an entire workflow demo of running a company would be too much work, so for this demo, I will show you one part of the workflow: checking the calendar and messaging a summary with attendees every day at a set time.

You could have it run every X hours or every single day at a fixed time. After each interval, the model will do as said above (Obviously, the idea is too naive, but it's just for this demo.) The possibilities are endless.

Keep this in mind: “anything that you can do manually on the internet, you can automate with OpenClaw.” So, you get the idea.

💁 NOTE: If you're serious about this idea, it's better to run this on a VPS or a Mac Mini, because you mostly don't have your personal PC running 24/7.

Here's the demo:

Conclusion

So far, you've learned how to run a fully functioning company with just yourself and a bunch of OpenClaw agents, using Composio as the secure integration layer between OpenClaw and all your third-party apps.

Be sure to give a star to Composio and OpenClaw on their GitHub repositories.

If you found this article helpful, drop a like and share your thoughts in the comments below. 👇

Happy automating! 🥳

Shrijal AcharyaFollow

Full Stack SDE • Open-Source Contributor • Collaborator @Oppia • Mail for collaboration

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!

How to set up Secure OpenClaw and power it with 850+ SaaS Apps 🦞🔒

Shrijal Acharya — Thu, 05 Mar 2026 13:26:54 +0000

OpenClaw has been showing up in my feed way too much, so I finally sat down and tested it properly, and yeah, it comes with a few real problems.

In this post, I’ll cover what OpenClaw is, how to set it up, where the security risks really come from, and how to use safer remote integrations so you can make it a bit more secure and save yourself some stress.

TL;DR

If you just want the takeaway, here’s the deal with OpenClaw:

OpenClaw is a local agent gateway. It is the layer that connects your LLM (OpenAI, Anthropic, etc.) to real tools and local execution.

The “special sauce” is the package. People like it because it ships as a usable bundle: built-in skills, a simple “agent brain” file (SOUL.md), and easy chat support like messenger integrations.

Security is the big problem. By design, it can touch files, run commands, and pull third-party skills. The least-bad way to use it is with remote, sandboxed integrations (which I’ve shown how to set up).

Also, watch your token bill. It can be very inefficient and chew through credits fast, especially if you’re using hosted models instead of a local LLM.

Overall, you'll learn everything you need to understand and start with OpenClaw (and make it slightly better with secure integrations).

What's OpenClaw?

OpenClaw is a personal AI assistant you run on your own machine (or a server you own). It is not a new model. It is the thing that actually sits between your model provider (OpenAI, Anthropic, Kimi, etc.) and the stuff you want done, such as messaging, tools, files, and integrations.

Take this as a mental model:

Your LLM is the brain (thinks)
OpenClaw is the body (it can do things)
The Gateway is the receptionist (routes messages in and results out)

So when people say “OpenClaw turns an LLM into an agent,” what they really mean is: it gives the model a runtime that can call tools, keep state, and show up where you already chat (WhatsApp, Telegram, Slack, Discord, etc.).

Now, that's just the gist. There's a lot more to understand. I assume you've already worked with it, so I'm not going any deeper than this in the intro.

What's Special than something like Manus? 🤔

Manus is essentially "agent as a product," but you're limited to their UI, tools, rules, and cloud.

OpenClaw is more like “agent as a kit.” It’s meant to be installed, set up, and shaped around your own workflow. You decide what models it uses, what tools it can touch, what data it can access, and where it runs.

That's the biggest difference.

💁 "Manus is for convenience, and OpenClaw is for control."

Wow, that was a nice line I came up with on the fly. 😂

OpenClaw Installation

You’ve got two clean ways to install OpenClaw. If you just want it running quickly, do the normal installation. If you’re even slightly paranoid (which you should be 😮‍💨), do Docker.

The core requirement is Node ≥ 22.

Option 1: Normal install (recommended for most people)

Prereqs: Node 22+ and an API key (OpenAI, Anthropic, OpenRouter, whatever you’re using).

Install OpenClaw:

curl -fsSL https://openclaw.ai/install.sh | bash

Run onboarding (this sets up provider auth + gateway settings and can install the background service):

openclaw onboard --install-daemon

Check the gateway status (if you installed the service, it should already be running):

openclaw gateway status

Optional: Open the Control UI:

openclaw dashboard

Option 2: Docker (more isolated and secure)

Docker is great when you want a throwaway environment or isolation from your host, but it introduces an important rule:

ℹ️ Containers only see plugins and config if they share the same OpenClaw state directory/volume. So, it comes with a little complexity.

Clone and start the Docker stack:

git clone https://github.com/openclaw/openclaw
cd openclaw
./docker-setup.sh

💡 To know more about how/what it does, visit the OpenClaw Docker Quickstart

Control UI gotchas

If you open the Control UI, and it shows something like:

unauthorized: gateway token missing

That's normal. The UI needs a gateway token to connect.

Get your token:

cat ~/.openclaw/openclaw.json | jq -r '.gateway.auth.token'

Make sure jq is installed on your machine. Or, you can manually get the token from the config file ~/.openclaw/openclaw.json.

Then either:

Paste it in the UI (Overview → Gateway Access → Gateway Token)

Use a URL that includes it, for example via:

openclaw dashboard --no-open

OpenClaw is bad for Security

OpenClaw’s whole selling point is also the problem: it can read/write files, run shell commands, and load third party “skills.” That is basically “download random code from the internet and run it with your permissions,” except now an LLM is the one executing.

What’s actually gone wrong in the wild (already):

Malicious skills on ClawHub: researchers found hundreds to thousands of skills that were straight up malware or had critical issues, including credential theft and prompt injection patterns.
Prompt injection turning into installs: there’s been at least one high profile incident where a prompt injection was used to push OpenClaw onto machines via an agent workflow.
Exfiltrate API keys and tokens: When your agent has full control of the computer, and when compromised, it can easily exfiltrate the API keys and tokens to attackers.

If you’re still going to run it, do the bare minimum to not get cooked:

Don't trust skills you don't know. If you didn’t read it, don’t install it.
Prefer OAuth-hosted integrations over pasting keys locally.
Run it sandboxed (Docker) and keep it away from your real home directory.

If you want to read more on OpenClaw’s security posture, we have a nice piece on it: OpenClaw is a Security Nightmare Dressed Up as a Daydream

Setting up safe Integrations

So enough of that. Let's look into how you can make it a bit more secure.

I assume you already have OpenClaw installed and have already done the initial setup onboarding. We’ll use Composio plugin, which gives us access to 850+ SaaS apps like Gmail, Outlook, Canva, YouTube, Twitter and more without you needing to manage OAuth tokens and integrations.

Contrary to OpenClaw’s native integrations, the credentials do not stay in your system and neither a compromised Claw can access them. The credentials are securely hosted and managed by Composio.

1. Install Composio Plugin

Composio’s OpenClaw plugin connects OpenClaw to Composio’s MCP endpoint and exposes third-party tools (GitHub, Gmail, Slack, Notion, etc.) through that layer without you needing to handle auth hassles.

openclaw plugins install @composio/openclaw-plugin

2. Composio Plugin Setup

Log in at dashboard.composio.dev
Choose OpenClaw as the client.
Copy your consumer key (ck_...) from the Composio dashboard settings, then set it:

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

3. Verify the plugin loaded

openclaw plugins list
openclaw logs --follow

You're looking for something like "Composio loaded" and a "tools registered" message.

If the plugin is "loaded", it means that you can now successfully access Composio.

Here's how it works:

If a tool returns an auth error, the agent will prompt you to connect that toolkit at dashboard.composio.dev.

Here's how the configuration looks:

{
  "plugins": {
    "entries": {
      "composio": {
        "enabled": true,
        "config": {
          "consumerKey": "ck_your_key_here"
        }
      }
    }
  }
}

You can configure the following options directly from the config file:

enabled: enable or disable the plugin
consumerKey: your Composio consumer key
mcpUrl: the MCP server URL. By default, it's https://connect.composio.dev/mcp

Previously, you had to configure API keys per integration, but with Composio you don't have to care about any of that. Just make sure not to leak the consumer key that we generated.

And it's that simple. Everything works out of the box as you would use any other OpenClaw plugins!

Now, to test if it works, head over to the Control UI chat and send a message, something like:

“List the Composio tools you have available. Only print the result here”

If it asks you to connect the tools, head over to dashboard.composio.dev and connect each of the tools you require. It's as simple as clicking Connect.

All the integrations you use are OAuth hosted, and only the tools you connect will be available to OpenClaw. Nothing more than that.

Wrap Up!

OpenClaw is really useful for some people (not everyone), but it’s also risky. It can touch your files, run commands, and pull in third party skills, which can include malware, like we discussed. It’s a local agent gateway with everything: your filesystem, your shell, and whatever credentials you put into it. That power is the whole point, and it’s also the danger.

So if you’re going to use it, seriously consider OAuth-hosted safe integrations instead of pasting API keys everywhere. It’s an easy way to reduce the chance of a disaster.

And, if you're looking for some secure alternatives, find it here: Top 5 Secure OpenClaw Alternatives

That’s it for this post. Hope it helped, and I’ll see you next time. ✌️

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.

🖐️Top 5 secure OpenClaw Alternatives you should consider 👀

Shrijal Acharya — Tue, 17 Feb 2026 12:59:41 +0000

OpenClaw is everywhere right now, and I get the hype. I’ve been seeing it all over my feed lately, and it’s clearly clicking with a lot of people. 👌

After using it for quite some time myself, it feels a bit too noisy, and not every tool works the same way for every person.

Whenever something starts trending this hard, it’s a good excuse to look around, especially if you’re after something more minimal.

And now, OpenClaw may have its 4th rename to be ClosedClaw very soon. 🤷‍♂️ You never know with OpenAI.

Why OpenClaw alternatives?

OpenClaw is super powerful, no doubt, but it comes with two big headaches, and you probably have already felt them yourself.

Security
Setup Friction
Security

When your agent can read files, run shell commands, and pull in third-party “skills,” you are basically giving it the keys to your machine. The skill marketplace has already turned into a real problem, with researchers finding hundreds of malicious skills.

If you are not auditing everything you install, it is easy to get yourself cooked.

Setup Friction

The “self-host it and wire up” path is fun if you like tinkering, but it is also where most people get stuck. You end up handling gateways, background services, tokens, and permission issues (most of the time).

And it's not that you're probably going to use all the features that come with the bloated app, just a few, for most people, so alternatives often could be a good choice.

Below are five OpenClaw alternatives that can cover the same ground, often with a smoother and more minimal experience, depending on what you’re building.

1. TrustClaw

ℹ️ Rebuilt from scratch on OpenClaw's idea with 1000+ tools, with a focus on security.

TrustClaw is for those who like the idea of OpenClaw but don't want to hand over their passwords to the agent and run it locally.

It's built by the Composio team, and the pitch is basically: you get an agent that is available 24/7, capable of taking real actions across a vast number (500+) of apps, but the risky parts like credentials and code execution are handled in a more controlled way.

What makes it different?

OAuth-only auth: You connect apps the normal way (OAuth), so you are not pasting API keys or passwords into config files.
Sandboxed execution by default: Every action runs in an isolated cloud environment that disappears when the task finishes. So you are not running “agent code” locally with your permissions.
Managed tool surface: Instead of pulling random community “skills” from a public registry, TrustClaw uses Composio’s managed integrations and tooling.
Audit trails + kill switch: It keeps a full action log, and you can revoke access with one click if you ever need to.

The last point is important because agent toolchains are a real security risk right now. These marketplaces, with just one random add-on, can trick you into running malware. This has already happened in the past. Ref: OpenClaw’s AI ‘skill’ extensions are a security nightmare

The kind of prompts it’s built for

“Handle my customer complaints and log in Notion”

It finds the right tools, fetches emails, creates drafts, and writes Notion pages (using tools such as: GMAIL_FETCH_EMAILS, GMAIL_CREATE_DRAFT, NOTION_CREATE_PAGE).
“Pull all Reddit threads mentioning [competitor] from the last 3 months, analyze sentiment...”
“Summarize all Slack messages in #product-feedback from this week...”

Why it’s comparatively better (for most of you)

Setup in seconds (vs. 30 to 60 minutes of tunnels and local setup)
Encrypted credentials managed by Composio (vs. plaintext local config)
Remote sandbox (vs. local machine execution)
Managed tool surface (vs. unvetted public skill registry)
Action logs + one-click revocation (vs. digging through config files)
and no need for Mac Mini 🤷‍♂️

Quick start

Go to TrustClaw and hit Get Started.
Connect the apps you want (OAuth flow).
Give it a task in plain language, or schedule one to run while you are offline.

Here's a demo: 👇

// Detect dark theme var iframe = document.getElementById('tweet-2022518658048888916-653'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2022518658048888916&theme=dark" }

It's that simple, so now you have OpenClaw that runs completely in the cloud with managed permissions and the tools you require.

2. ZeroClaw

ℹ️ Written in Rust, it runs even on $10 hardware with <5MB RAM.

ZeroClaw keeps the agent stack lean. Instead of a big local setup with lots of moving parts, you get a lightweight Rust binary that starts fast and runs comfortably on cheap hardware. If you care more about speed, stability, and low resource use, this one hits the sweet spot.

What makes it different?

Ultra lightweight: designed to keep CPU and RAM usage low.
Quick boot: fast startup, good for bots and always-on tasks.
Modular: swap models, memory, tools, and channels without rewriting everything.

Why pick it over OpenClaw?

You want something minimal and predictable.
You’re running on a small VPS / Raspberry Pi / home lab.
You don’t need a huge plugin marketplace, you need a tool that just runs.

Quick Start

git clone https://github.com/zeroclaw-labs/zeroclaw.git
cd zeroclaw
cargo build --release
cargo install --path . --force

# quick setup with openrouter
zeroclaw onboard --api-key sk-... --provider openrouter

# chat
zeroclaw agent -m "Hello, ZeroClaw!"

3. NanoClaw

ℹ️ OpenClaw's alternative that runs entirely in a container for security.

NanoClaw is basically the same thing but runs completely isolated inside a Docker container. The whole idea is simple: keep the codebase small, and put the risky stuff (bash, file access, tools) inside an isolated container so it can only touch what you explicitly mount.

That's pretty much the idea of NanoClaw.

What makes it different?

Container isolation by default: runs in Apple Container (macOS) or Docker (macOS/Linux), with filesystem isolation.
Per-chat sandboxing: each group/chat can have its own memory and its own mounted filesystem, separated from others.
Built on Anthropic’s Agents SDK: it’s basically designed to work nicely with Claude’s agent tooling and Claude Code.
WhatsApp + scheduled jobs: message it from your phone, and set recurring tasks that ping you back.

Quick start

git clone https://github.com/gavrielc/nanoclaw.git
cd nanoclaw
claude

Then run /setup. Claude Code handles everything: dependencies, authentication, container setup, and service configuration.

Here's a quick demo: 👇

4. nanobot

ℹ️ Ultra lightweight AI assistant built with Python.

Nanobot, as the name suggests, is quite small. The core agent is about ~4,000 lines of code, and the repo even publishes a live count you can verify with their script. That is the whole vibe: small enough that you can actually read it, trust it, and change it.

What makes it different?

Core size metric: ~4,000 LOC, with a “real-time” line count shown in the README (and a script to verify).
MCP support (fresh): added 2026-02-14, so it can plug into MCP tool servers without you reinventing the plumbing.
Runs where you already are: built-in “gateway” mode supports a bunch of chat surfaces like Telegram, Discord, WhatsApp, Slack, Email, and more.

Quick Start

pip install nanobot-ai

nanobot onboard
nanobot agent          # local interactive chat
nanobot gateway        # run it as a chat bot (Telegram, Discord, WhatsApp, etc)

Here's a quick architecture:

Here's a video to give you an idea of how it works: 👇

5. memU Bot

ℹ️ Built for 24/7 proactive agents designed for long-running use.

memU Bot is built for people who want an agent that keeps running and becomes more useful over time, instead of resetting to zero every time you open a new chat.

The site definitely looks like it was coded by a 12-year-old 😭, but don’t let that scare you off, because the product underneath is really good.

Under the hood, it’s tied to memU, NevaMind’s memory framework for long-running proactive agents, with a focus on reducing long-run context cost by caching insights.

What makes it different?

Always-on + proactive: it’s designed to sit in the background and capture intent (not just respond to prompts).
Memory system that scales: memU treats memory like a file system (categories, memory items, cross-links), so the agent can fetch relevant fragments instead of shoving the whole history into every request.

Quick start

It's a bit more involved than other options.

If you just want the product (memU Bot):

Go to memu.bot, enter your email, and get the download link they send you.
Install it like a normal desktop app (they provide a macOS .dmg in the tutorial flow).
Start it, connect the channel you want (Telegram, etc.), and let it run so it can build memory over time.

git clone https://github.com/NevaMind-AI/memU.git
cd memU

# Requires Python 3.13+
pip install -e .

# set your key (OpenAI is the default in their quick tests)
export OPENAI_API_KEY="your_api_key"

# quick test using in-memory storage
cd tests
python test_inmemory.py

Want persistent memory backed by Postgres + pgvector?

docker run -d \
  --name memu-postgres \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=postgres \
  -e POSTGRES_DB=memu \
  -p 5432:5432 \
  pgvector/pgvector:pg16

export OPENAI_API_KEY="your_api_key"
cd tests
python test_postgres.py

They also provide a small runnable "proactive loop" example if you want to see the behavior without going through tests:

cd examples/proactive
python proactive.py

There's also a Cloud version which you can try out as well.

It might be worth checking this out: 👇

If you know of any other useful OpenClaw alternative tools that I haven't mentioned in this article, please share them in the comments section below. 👇🏻

That concludes this article. Thank you so much for reading! 🫡

Shrijal AcharyaFollow

Full Stack SDE • Open-Source Contributor • Collaborator @Oppia • Mail for collaboration