More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Whatsapp AI Agent

    1

    Generates a working WhatsApp AI agent in under a minute. Bring your own model and memory backend.

    Free

    1 useSecurity scanned
    Whatsapp AI Agent

    Whatsapp AI Agent

    Example session with this skill installed

    Generate a new WhatsApp agent using local memory. I don't need the productivity tools. Put it in a folder called 'my-support-bot'.

    • Read your context and instructions
    • Compiled the whatsapp ai agent

    I ran the generator for your WhatsApp AI agent in the my-support-bot directory. The project is configured to use Anthropic as the model provider and local SQLite-based memory.

    Project Details

    ComponentSelectionDescription
    Model providerAnthropicUses @ai-sdk/anthropic via the Vercel AI SDK
    Memory backendLocal (SQLite/LibSQL)No account needed, BM25 keyword search, runs fully offline
    Productivity agentOffSkipped — no Gmail/Calendar tools included

    Files generated

    • index.ts — the agent itself: model, memory, routing, and WhatsApp wiring
    • package.json — dependencies scoped to exactly what this build needs: @wappy_ai/core, @wappy_ai/harness, @wappy_ai/whatsapp, @ai-sdk/anthropic, ai, @libsql/client, dotenv
    • .env.sample — only the keys this specific build needs: ANTHROPIC_API_KEY, WHATSAPP_PHONE_NUMBER_ID, WHATSAPP_ACCESS_TOKEN, WHATSAPP_VERIFY_TOKEN, WHATSAPP_APP_SECRET
    • README.md — your project's own next steps
    • WHATSAPP_SETUP.md — the full Meta app + webhook walkthrough

    Next steps

    cd my-support-bot
    cp .env.sample .env   # fill in your Anthropic key + WhatsApp credentials
    npm install
    npm run dev            # boots the server, opens a tunnel, prints the webhook URL for Meta
    

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Here's the rewrite — "scaffold"/"scaffolding" replaced throughout, and "production-ready" softened to something we can actually back up:


    Stop wasting time writing boilerplate for WhatsApp integrations. This skill generates a complete, runnable TypeScript project for building AI agents that live directly on WhatsApp. It uses the open-source Wappy SDK to ensure your data and model keys stay on your own infrastructure rather than routing through third-party middleware.

    What it does

    • Project generation produces a complete, working TypeScript codebase instead of empty templates.
    • Provider selection configures the agent for OpenAI, Anthropic, Gemini, or local-first Ollama.
    • Memory management implements SQLite/LibSQL for local keyword search or Cognee for knowledge graphs.
    • Tool integration sets up optional read-only Gmail and Google Calendar tools for productivity workflows.
    • Environment setup produces a tailored .env.sample containing only the keys required for your specific build.

    How it works

    1. Interactive mode initiates a three-question interview to define the model, memory, and features.
    2. Scripted execution uses flags like --model, --memory, and --productivity for automated CI/CD or non-interactive setups.
    3. Environment configuration prepares the project for local execution via npm run dev with automatic webhook tunneling.

    Frameworks & tools

    TypeScript, Node.js 22+, Wappy SDK, SQLite/LibSQL, Cognee, and the Meta WhatsApp Cloud API.

    Why this beats prompting it yourself

    Prompting an LLM to write a WhatsApp agent often results in outdated API calls or missing webhook logic. This skill provides a verified, structured pipeline that handles message routing and tool-call decisions out of the box.

    Use cases

    • Build a private WhatsApp assistant using local Ollama for maximum privacy.
    • Create a customer support bot with a RAG backend for answering product questions.
    • Develop a personal productivity agent that queries your Google Calendar via chat.

    Known limitations

    Requires Node.js 22 or higher. Users must manually create a Meta Developer App to obtain WhatsApp Cloud API credentials.


    Want this written into AGENSI_SUBMISSION_NOTES.md so it's saved alongside the other listing copy, or is this just for pasting directly into the listing form?

    Requires Node.js 22+. Users must independently set up a Meta developer app and provide their own API keys for LLM providers.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    • Free with an Agensi account

    Requires

    Node.js

    Permissions

    Terminal / Shell
    Network Access
    Environment Variables
    Listed28 days ago

    What's inside

    Frequently Asked Questions

    This skill automates the creation of a full-stack TypeScript project, providing verified boilerplate for WhatsApp API integration, message routing, and local memory management that would otherwise take hours to write manually.

    The generated project supports industry leaders like OpenAI, Anthropic, and Gemini, as well as Ollama for developers who prefer running local, privacy-focused models.

    You will need Node.js 22 or higher and a Meta Developer account to access the WhatsApp Cloud API; the skill handles the rest by scaffolding the environment and webhook tunneling.

    Yes, the skill allows you to choose between SQLite/LibSQL for traditional keyword-based memory or Cognee for building advanced knowledge graphs within your WhatsApp bot.

    You receive a complete, production-ready TypeScript codebase including pre-configured tool integrations for Google services, a tailored .env setup, and the open-source Wappy SDK framework.

    Unlike raw LLM prompts which often use deprecated API versions, this skill provides a structured, tested pipeline that ensures your webhook logic and tool-calling functions are current and functional.