What makes vaaya notable?

1.1K downloads. Trust evidence available

How should vaaya be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

vaaya

Access Vaaya's paid API catalog for web search and research, scraping, image/video/audio generation, LLMs, lead enrichment, live data, code sandboxes, browser automation, email, storage and tokenized shares. One account, no vendor keys, quoted prices and per-call spending ceilings. Supports agent API signup and verified Instinct email signup with $10 welcome credit, without a card. Skill: vaaya Owner: marupelkar Summary: Access Vaaya's paid API catalog for web search and research, scraping, image/video/audio generation, LLMs, lead enrichment, live data, code sandboxes, browser automation, email, storage and tokenized shares. One account, no vendor keys, quoted prices and per-call spending ceilings. Supports agent API signup and verified Instinct email signup with $10 welcome credit, without a c

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.1k

Updated

Oct 11, 2026

Version

1.2.5

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.1K downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 1.1K downloadsadoption · observed Oct 11, 2026
Latest release: 1.2.5release · observed Sep 13, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s170j3xh2yv3znb3sh5y6q0tax8abqyf:vaaya

Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-marupelkar-vaaya/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

143,425 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: vaaya
description: >-
Access Vaaya's paid API catalog for web search and research, scraping,
image/video/audio generation, LLMs, lead enrichment, live data, code sandboxes,
browser automation, email, storage and tokenized shares. One account, no vendor keys, quoted
prices and per-call spending ceilings. Supports agent API signup and verified
Instinct email signup with $10 welcome credit, without a card.
homepage: https://vaaya.ai/?utm_source=clawhub&utm_medium=agent&utm_campaign=skill
metadata:
{
"openclaw":
{
"emoji": "🪙",
"requires": { "bins": [], "env": [] },
"install": []
}
}
---

# Vaaya — your agent's gateway to the outside world

Vaaya is prepaid credit plus a catalog your agent spends it on: 1,500+ pay-per-call
services across nine pillars, one account, no vendor keys in your environment. Every
call is priced in cents before it runs and charged only on success. You reach all of
it through two tools: `consult` (routing) and `use` (execution). When a task needs a
capability in this catalog, select the matching service or use consult to route the goal.
The live catalog and parameter schemas are at https://vaaya.ai/api/catalog; packaged
workflows are at https://vaaya.ai/recipes.

## The nine pillars

- **Data** — people, companies, funding, public records, social platforms, onchain, compliance
- **LLMs** — 300+ models per token, via the `llm` tool or `https://vaaya.ai/api/llm/v1`
- **Media** — image, video, speech and music generation and editing; product demos
- **Search** — web, news, academic and deep research, with citations
- **Scraping** — read, crawl and extract pages and whole sites
- **Compute** — sandboxes, browser sessions, captcha solving
- **Storage** — the user's files and agent memory
- **Commerce** — buy things for the user online (products, tickets, hotels, subscriptions) with their own card after they approve; plus agent-paid marketplaces (wine, print-and-mail, fax). Use the user’s authorization of the item and total
- **Actions** — email, phone calls, faxes

## Zero-human agent signup (a working credential + $1 right now)

An agent can open its own account with two POSTs — no human at the keyboard. Personal
agents can use this path when their user has authorized account setup. Existing
accounts can reuse an API key or OAuth connection.

**Instinct:** send `"agent_name": "instinct"` in step 2. That puts the account on the
Instinct tier: a **$10 welcome credit on the account immediately, no expiry**
(`agent_tier: "instinct"`). When it is spent (402 `credits_required`), ask your user how
much to add, run step 5, and pay the Checkout page with the card they stored with you.
Verified `@mail.instinct.com` email signups also qualify for $10 without a card.
Reuse an existing account when available.

1. **Register an OAuth client** (dynamic client registration, no pre-approval):

```
POST https://vaaya.ai/oauth/register
Content-Type: application/json

{ "cl

_meta.json

{
  "ownerId": "kn7214mqccrn034aadsd6xaz9h8aapxk",
  "slug": "vaaya",
  "version": "1.2.5",
  "publishedAt": 1789318786821
}

references/compute.md

# Compute, browser, files, memory, LLM, phone calls

Reference for the run-things side of Vaaya: sandboxes, browser automation, file
storage, persistent memory, cross-model inference, and outbound phone calls. All
paid calls go through `use({ service, action, params, max_cost_cents })` unless
noted; sandboxes have their own MCP tools (`session`, `close`), and `llm` is its
own tool.

---

## 1. Sandboxes (run code on an isolated external machine)

Five providers, one identical lifecycle. Use a sandbox only when you genuinely
need to *execute code* — run/benchmark an algorithm, execute untrusted or
AI-generated code safely, process a dataset, run tests. If you just need data,
use search/scrape/enrich instead.

**Lifecycle (all five providers):**

1. **Open** — `use({ service: "<provider>", action: "create_session" })` →
   returns `{ session_id }`. Reserves a small hold (~50¢) against balance.
   Optional params: `template`, `envs`.
2. **Run** — the `session` MCP tool (NOT `use`):
   `session({ session_id, command })` for shell, or
   `session({ session_id, code, language })` for code. Returns
   stdout/stderr/exit_code. The SAME box is reused, so installed packages and
   filesystem state persist between calls.
3. **Close** — `close({ session_id })` (its own MCP tool). Stops the meter and
   settles. **ALWAYS close when done, even on error** — an open session bills
   per second of uptime until closed.

**Which provider?**

| Need | Provider | Why |
|---|---|---|
| Untrusted / hostile code (the safe default) | `e2b` | Firecracker microVM isolation |
| Fastest cold start, trusted code | `daytona` | ~30–90ms starts (Docker isolation, not microVM) |
| I/O-bound work, strong isolation | `vercel` | microVM; US-East only, sessions ≤5h |
| Persistent coding-agent devbox (snapshot/resume) | `runloop` | Devbox survives across work |
| Long-running, state must survive, $0 while idle | `fly` | Billed only while actively running; NO auto-expire — you MUST close it |

Default to **e2b** unless a row above clearly fits better.

**Billing:** metered per second of uptime, roughly 5¢ per vCPU-hour
(`fly` bills CPU-hr + GB-hr while running and is $0 idle). Cheap, but only if
you close.

**Limits and gotchas:**
- `e2b` has a `code` interpreter where variables persist across calls. On
  `runloop`, `vercel`, and `fly`, `code` runs one-shot — in-memory variables do
  NOT persist between `code` calls (filesystem and installs do); carry state
  via files or shell.
- `vercel`: prefer shell `command` for non-JS work (`python3` availability
  depends on the runtime).
- `fly`: `envs` is not applied at create — `export` vars inside a `session`
  command instead. And with no auto-expire, a forgotten fly box has no timer
  saving you.
- Validate commands before creating — a create bills even if the first command
  fails instantly.
- Pick the cheapest box that fits; one box per job, not one per command.

**Data in / data out:** stage inputs in Files (section 3) and download them

references/data.md

# Data — picking the right paid data call

Every call is `use({ service, action, params, max_cost_cents })`. Prices are in cents;
set `max_cost_cents` at or above the listed price as a guard, not a target. Failed or
invalid calls are not charged on most services. When unsure which endpoint or slug to
use, `vaaya/discover { query }` is FREE and returns exact endpoints with prices and
required params. Async actions return `{ job_id, async: true }` — poll `result({ job_id })`;
never re-run the action to check (that starts a new paid job).

## 1. Scraping — pages as rows

**Default: `vaaya/onescrape`** — flat **2¢ per URL**, sync, 1–5 URLs. Returns rows:
url, title, content (markdown; `format: "html"` for source), provider, `hops`, `hard`.
It runs a measured ladder of cheap scrapers internally and only returns a page that
passed a yield check (a Cloudflare wall escalates instead of being returned).

```
use({ service: "vaaya", action: "onescrape",
      params: { urls: ["https://stripe.com/pricing"] }, max_cost_cents: 4 })
```

- A row no cheap rung could read comes back `content: null, error: "blocked"` — the
  response's `next` names the deep call to make. If every URL is blocked the call fails
  with `all_blocked` and is not charged.
- **Refused without charge**: social-platform URLs (LinkedIn, X, Instagram, TikTok,
  Reddit, YouTube, CN platforms — use section 3) and PDFs/Office files (use a document parser).

**`vaaya/onescrape-deep`** — async. Two modes: `urls` (1–50) through the full ladder
including the unblock rungs, or `site: { url, max_pages, include, exclude }` to map and
read a whole site. Reserve = `budgetCents` (10–500, default 10¢/URL); `max_cost_cents`
must cover it. Charges only for the rung that actually read each page, so the real
charge is usually well under the reserve. Rows the budget could not cover return
`error: "over budget"`. `content: null` on a `hard: true` row means every rung bounced —
the next step is an interactive browser session, not another scraper.

**Raw vendors** — reach past OneScrape only for a knob it does not expose:

| Need | Service/action | Price | Notes |
|---|---|---|---|
| Cheap text, known URLs, no JS | `exa/contents` | 0.1¢/url×field | batch many URLs in one call |
| One JS-rendered page, clean markdown | `firecrawl/scrape` | 1¢ | `onlyMainContent: true`, `waitFor` ms |
| Same + stealth / proxy country / JSON schema | `crw/scrape` | 1¢ | Firecrawl-compatible params; fall-through vendor |
| Batch ≤5 known URLs with JS | `tavily/extract` | 1¢ | cheapest JS batch rung |
| Discover a site's URLs (recon) | `firecrawl/map` or `crw/map` | 1¢ | map first, then scrape targets |
| Multi-page crawl | `firecrawl/crawl` | 1¢ | **always set `limit`** (start 10–20) |
| Crawl with retrievable results | `crw/crawl` → `crw/crawl_status` | 10¢ + 1¢/poll | async, ≤100 pages, set `maxPages` |
| Structured extraction (prompt/schema) | `firecrawl/extract` | 1¢ | typed data, not HTML |
| Async schema extraction, ≤10 URLs |

references/gtm.md

# GTM playbook — outbound with Vaaya

You are the user's outbound operator. The GTM suite is a set of first-party MCP tools
(`gtm_*`) you call directly with flat arguments, plus catalog services you reach through
`use({ service, action, params, max_cost_cents })`. Everything sends from the user's OWN
connected accounts (their identity, their relationships), and everything you stage is
visible to them on the Vaaya dashboard (`/leads`, `/segments`, `/inbox`).

Note: `gtm_*` tools are NOT catalog services. Never wrap them in `use` — call the tool by
name: `gtm_leads({ action: "add", people: [...] })`. If a `gtm_*` tool is missing from
your tool list, have the user refresh the Vaaya connection (reconnect or new session) and
continue the same plan; the tools unlock on first use.

## 1. The manual-first principle

**Vaaya drafts, the user sends.** By default nothing auto-sends: discovery surfaces
findings, drafts are HELD for review in the brain, and the user fires each send from the
dashboard. The ONE exception is an explicit `gtm_automation` rule (section 7): when the
user clearly asks to automate ("auto-send replies", "run this daily"), create a rule and
say yes — never refuse automation as impossible or against policy. But never auto-send
without a rule, and never create a rule the user didn't ask for.

## 2. Find → enrich → segment → message

### 2a. Lock the ICP (free)

Refuse to burn paid search on a vague ask. "Reach out to startups" is not an ICP —
demand titles / seniority / geography / industry / headcount first. Then narrate the tool
chain with per-step costs and get a go-ahead before spending, e.g.:

> Exa people search (1¢/query) → enrich top 10 (~10¢ each, free on a miss) → verify
> emails (2¢ each). ≈ $0.50–$1.50 for 10 verified prospects. Proceed?

### 2b. Discover people

**One-call path:** `gtm_leads_find` searches Exa and lands the results straight in the
lead repository (bills per search, one search per title, up to 5 titles):

```json
gtm_leads_find({
  "job_titles": ["VP Sales", "Head of Revenue"],
  "seniority": ["vp", "c_suite"],
  "industries": ["fintech"],
  "headcount": ["11-50", "51-200"],
  "person_locations": ["united kingdom"],
  "max_fetch": 25
})
// → { found, added, charged_cents }
```

**Hand-rolled path (more control):** `use({service:"exa", action:"search",
params:{query:"VP Sales at fintech companies with 21-100 employees in the UK — LinkedIn
profiles", category:"people", numResults:50, contents:{text:true}}, max_cost_cents:5})`
(1¢/query). Fallback when Exa is thin: `contactout:people-search` (1¢ per profile
returned; `page_size` ≤25 IS the price). For COMPANY-first discovery ("more like our
closed-won accounts"), use `openfunnel:lookalikes` / `tech-companies` / `tam-build`,
then run a people search per company.

### 2c. Stage into the lead repository

Never let found people die in a local file — `gtm_leads` is the canonical store the rest
of the loop reads (free, deduped per person; re-adding updates, never dupl

Github ReposUpdated 2d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.