> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bothive.cloud/llms.txt
> Use this file to discover all available pages before exploring further.

# Bothive vs Vercel AI SDK

> Platform vs library — why Bothive wins for AI agent builders.

<div className="hero-container">
  <p className="hero-subtitle">
    Vercel AI SDK is a library for developers. Bothive is a complete platform for everyone.
  </p>
</div>

<Note>
  **TL;DR** — Vercel AI SDK gives you building blocks. Bothive gives you the whole building. Use Vercel AI SDK if you want full control over every layer. Use Bothive if you want to ship AI agents fast without managing infrastructure.
</Note>

## Side-by-side comparison

| Feature            | Vercel AI SDK           | Bothive                              |
| ------------------ | ----------------------- | ------------------------------------ |
| **What it is**     | JavaScript library      | Full platform + declarative language |
| **Target user**    | Developers only         | Developers + founders + non-coders   |
| **Deployment**     | You host it             | We host it                           |
| **Language**       | TypeScript / JavaScript | HiveLang v5 (declarative)            |
| **Multi-agent**    | Manual orchestration    | Built-in swarms                      |
| **Marketplace**    |                         | HiveStore                            |
| **Monetization**   |                         | Sell your bots                       |
| **Visual builder** |                         |                                      |
| **Integrations**   | You build them          | Many pre-built, OAuth-managed        |
| **Memory system**  | You build it            | 4 types, built-in                    |
| **Observability**  | You add it (external)   | Built-in traces on every run         |
| **Channels**       | You wire them           | Web, Telegram, Slack, API            |
| **Pricing**        | Free (library)          | Freemium (platform)                  |

## Code comparison: Twitter Bot

The same task — a bot that posts daily AI summaries to Twitter.

<CardGroup cols={2}>
  <Card title="Vercel AI SDK" icon="code" className="glass-effect">
    ```typescript theme={null}
    // 50+ lines of setup required
    import { TwitterApi } from 'twitter-api-v2';
    import { openai } from '@ai-sdk/openai';
    import { generateText } from 'ai';
    import { schedule } from 'node-cron';

    const client = new TwitterApi({
      appKey: process.env.TWITTER_API_KEY,
      appSecret: process.env.TWITTER_API_SECRET,
      accessToken: process.env.TWITTER_ACCESS_TOKEN,
      accessSecret: process.env.TWITTER_ACCESS_SECRET,
    });

    async function generateSummary() {
      const { text } = await generateText({
        model: openai('gpt-4o'),
        prompt: 'Generate a daily AI news summary',
      });
      return text;
    }

    async function postToTwitter(text: string) {
      try {
        await client.v2.tweet(text);
      } catch (error) {
        console.error('Failed:', error);
      }
    }

    schedule('0 9 * * *', async () => {
      const summary = await generateSummary();
      await postToTwitter(summary);
    });

    // Still need: hosting, cron setup, env vars,
    // monitoring, error alerts, retry logic...
    ```
  </Card>

  <Card title="Bothive HiveLang v5" icon="bolt" className="glass-effect">
    ```hivelang theme={null}
    bot DailySummary {
      description: "Posts daily AI summaries to Twitter"

      capabilities {
        twitter.post
        ai.generate
      }

      instructions {
        Generate an engaging daily summary of the
        most important AI news. Keep it under 280
        characters. Use a professional but accessible tone.
      }

      on schedule "0 9 * * *" {
        summary = call ai.generate with {
          prompt: "Daily AI news summary"
        }
        call twitter.post with { text: summary }
      }
    }
    ```

    **12 lines. Auto-deployed. No hosting needed.**
  </Card>
</CardGroup>

## Multi-agent comparison

Building a research + writing swarm:

<CardGroup cols={2}>
  <Card title="Vercel AI SDK" icon="code" className="glass-effect">
    ```typescript theme={null}
    // 100+ lines
    import { openai } from '@ai-sdk/openai';
    import { streamText, tool } from 'ai';
    import { z } from 'zod';

    const searchTool = tool({
      description: 'Search knowledge base',
      parameters: z.object({ query: z.string() }),
      execute: async ({ query }) => {
        // Your search implementation
        return results;
      },
    });

    async function researchAgent(query: string) {
      return streamText({
        model: openai('gpt-4o'),
        system: 'You are a research agent.',
        prompt: query,
        tools: { search: searchTool },
      });
    }

    async function writerAgent(research: string) {
      return streamText({
        model: openai('gpt-4o'),
        system: 'You are a writer.',
        prompt: `Write based on: ${research}`,
      });
    }

    // Manual orchestration, error handling,
    // state management still your problem
    ```
  </Card>

  <Card title="Bothive HiveLang v5" icon="bolt" className="glass-effect">
    ```hivelang theme={null}
    swarm ArticleWriter {
      agent Researcher {
        role: "Research topics thoroughly"
        capabilities { web.search, kb.query }
      }

      agent Writer {
        role: "Write engaging articles"
        capabilities { ai.generate }
      }

      on input {
        research = delegate to Researcher
          with { topic: input }
        article = delegate to Writer
          with { research: research }
        say article
      }
    }
    ```

    **20 lines. Orchestration built-in. Error recovery automatic.**
  </Card>
</CardGroup>

## Deployment: the real difference

**With Vercel AI SDK:**

1. Write all the code
2. Set up Next.js project
3. Configure environment variables
4. Set up database for history
5. Add authentication
6. Deploy to Vercel
7. Configure domains
8. Set up monitoring
9. Handle scaling

**With Bothive:**

1. Write HiveLang
2. Click Deploy
3. Done

## When to use each

<CardGroup cols={2}>
  <Card title="Use Vercel AI SDK when..." icon="code" className="glass-effect">
    * You're a developer who wants full control of every layer
    * You're adding AI features to an existing app with its own infrastructure
    * You have specific requirements that don't fit a platform model
    * You want to own the complete stack for compliance reasons
    * You're integrating AI into a highly customized frontend
  </Card>

  <Card title="Use Bothive when..." icon="rocket" className="glass-effect">
    * You want to build and ship AI agents fast
    * You want multi-agent swarms without manual orchestration
    * You want to sell or monetize your agents
    * You don't want to manage infrastructure
    * You want many integrations ready out of the box
    * You're not a developer (or you are, but want speed)
  </Card>
</CardGroup>

## The analogy

| Vercel AI SDK                             | Bothive                                 |
| ----------------------------------------- | --------------------------------------- |
| React — library, you build everything     | Shopify — platform, everything included |
| Gives you tools, you assemble the house   | Gives you the house, you decorate it    |
| Full flexibility, full responsibility     | Opinionated platform, fast results      |
| Free to use, you pay for your own hosting | Freemium, hosting included              |

## Why Bothive wins for agent builders

<CardGroup cols={2}>
  <Card title="HiveLang — Unique IP" icon="file-code" className="glass-effect">
    90-95% less code than Python/TypeScript. Declarative — describe what the agent does, not how. Built-in patterns for ReAct, tool calling, and multi-step workflows.
  </Card>

  <Card title="Platform, Not Library" icon="building" className="glass-effect">
    Hosting, auth, payment processing, analytics, monitoring — all included. You focus on agent behavior, not infrastructure.
  </Card>

  <Card title="HiveStore Marketplace" icon="store" className="glass-effect">
    Sell your agents. Recurring subscriptions, usage tracking, and automated payouts. Vercel AI SDK has no marketplace.
  </Card>

  <Card title="Multi-Agent Native" icon="network-wired" className="glass-effect">
    Swarms are first-class. Define complex multi-agent workflows in 20 lines. Vercel AI SDK requires 100+ lines of manual orchestration.
  </Card>
</CardGroup>

## Next reads

<CardGroup cols={3}>
  <Card title="HiveLang v5" icon="code" href="./hivelang" className="glass-effect" />

  <Card title="Get Started" icon="rocket" href="../quickstart" className="glass-effect" />
</CardGroup>