Vexa

Vexa

Open-source meeting bots and real-time transcription — cloud or fully self-hosted.

A bot joins your Google Meet, Microsoft Teams, and Zoom calls and streams speaker-attributed transcripts in real time — through our API or one *you* host — then feeds sandboxed agents that build a Markdown knowledge base your team owns. Apache-2.0, air-gap-ready. (Jitsi: join + capture offline-proven, live validation pending — #883.)

[vexa.ai](https://vexa.ai) runs Vexa 0.12 for meeting bots and transcription. Sandboxed knowledge agents are self-hosted only — self-host Vexa to run the full stack.

---

[Connect your agent](https://vexa.ai/connect?utm_source=github&utm_medium=readme) · [Get an API key](https://vexa.ai/start?utm_source=github&utm_medium=readme) · [Talk to the founder](https://cal.com/dmitrygrankin/web)

Why Vexa

Every meeting-AI tool you can buy sends your conversations to *their* cloud and rents you access back. Vexa inverts that: run the stack yourself, point it at your own models, own what your meetings become.

No one else has all three:

1. **Vexa is *in* the meeting.** A real bot joins Meet, Teams and Zoom — Jitsi offline-proven, live validation pending — and streams speaker-attributed transcripts live. That bot fleet is the genuinely hard part — every "chat with your docs" tool starts *after* a transcript exists. Vexa produces it.

1. Your knowledge is files you own. Meetings compile into Markdown in a git repo — portable, diffable, greppable. Knowledge as code.

1. Agents work it, safely. Sandboxed coding agents read and write that repo like developers — isolated ephemeral containers, no egress, thousands in parallel, on Docker or your Kubernetes.

Only here for the transcription API? It's a complete standalone product — send a bot,

read the stream, ignore the agent lane entirely.

---

⚡ Quickstart

Just want a bot in a meeting? Use the hosted service — no install. Sign in at vexa.ai/signin, copy your key from your account page, and send a bot:

curl -X POST "https://api.cloud.vexa.ai/bots" \

-H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \ -d '{"platform":"google_meet","native_meeting_id":"abc-defg-hij","bot_name":"Vexa"}'

New accounts get $2 of free bot credit, no card required — about 6 hours of bot time at $0.30/hr (pricing). More calls: Send a bot.

Or self-host the whole stack

That is also how you get the agent plane, which is not part of the hosted service. Self-host on one host, then explore it in the Terminal or drive it over the API. Linux (Ubuntu 24.04) is the production target; a Mac with Docker Desktop works fine for a local evaluation — everything runs in containers either way.

Prerequisites — make, Docker engine ≥ v26 (make all checks), and transcription: a free token at vexa.ai/account, or self-host the (GPU) transcription unit for a fully air-gapped setup. By default POST /bots requires STT and answers 503 when it is missing (make all warns when the credentials block in .env is empty). Capture-only is an explicit opt-out: {"transcribe_enabled": false} on the spawn (or set TRANSCRIBE_ENABLED=false for the deployment).

Build machine: make all pulls the published, release-validated images — no build, so a

modest box is fine. make lite (the single-container all-in-one image) is lighter still. Building

from this checkout instead (make dev, for contributors) wants 8 vCPUs and 16 GB RAM.

git clone https://github.com/Vexa-ai/vexa.git && cd vexa

make all # full Docker Compose stack — seeds .env, pulls the images (bot included),

prints your API key + URLs. Contributors: make dev builds from this checkout.

When make all finishes it prints your key and URLs:

  Terminal UI : http://localhost:13000     # the web workbench

API gateway : http://localhost:18056 # the API API key : vxa_…

Explore in the Terminal (the fast path)

The Terminal is the way to see what Vexa can do. Open `http://localhost:13000` — you're already signed in to a self-host account. From the workbench you can, with no curl:

• Send a bot — paste a Meet / Zoom / Teams / Jitsi URL; a bot joins as a participant.
• Watch the transcript stream in live, speaker-attributed, draft-then-confirmed.
• Chat with your workspace — ask an agent that has every captured meeting as context, and watch it commit what you decide.

Or drive it over the API

export API_KEY=vxa_...

export API_BASE=http://localhost:18056

WIN 1 — send a bot into a live call, then read the transcript as it streams

curl -X POST "$API_BASE/bots" \ -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \ -d '{"platform":"google_meet","native_meeting_id":"abc-defg-hij","bot_name":"Vexa"}'

curl -H "X-API-Key: $API_KEY" "$API_BASE/transcripts/google_meet/abc-defg-hij"

WIN 2 — ask an agent that has your whole workspace as context (answer streams back as SSE)

curl -N -X POST "$API_BASE/agent/chat" \ -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \ -d '{"prompt":"What did we decide in my last meeting?"}'

platform is google_meet · teams · zoom · jitsi; native_meeting_id is the code from the join URL. The agent reply streams as Server-Sent Events — message-delta frames carry the text, commit frames mark anything it recorded into your workspace.

---

🧩 How it works

One gateway, two domains — Meetings (capture) and Agents (work the knowledge) — both running on the same runtime: the engine that spawns every bot and every agent in its own sandboxed container.

A bot and an agent are the same `runtime.v1` workload — isolated, ephemeral, reaped on idle — so the machinery already proven by thousands of meeting bots is exactly what runs your agents. Every arrow stays inside your network.

---

⚙️ The agentic runtime

A CLI coding agent is just a process on Linux. The runtime makes that a multi-tenant, sandboxed execution layer safe to point at real business data — the same engine that already spawns Vexa's meeting bots in production.

• Isolated. Every dispatch gets its own container: no egress except brokered tools, and only its granted workspaces exist in its filesystem — enforced by the substrate, not by the agent. Agents never run in the control plane.
• Ephemeral. A container lives while it works and is reaped on idle; continuity is a session file in the workspace. Sub-second starts, thousands in parallel.
• Orchestration-agnostic. One runtime.v1 lifecycle, pluggable substrate — the same dispatch runs identically across:

Same control plane, same worker — only how the container is created changes. One laptop to a Kubernetes/OpenShift cluster, inside your walls.

---

🧠 Agents & your workspace

Capture is the front door; agents make the knowledge compound. Every meeting compiles into your workspace — a git repo of Markdown (an Open Knowledge Format kg/ bundle) that agents (Claude Code, Codex, …) read and write like developers work a codebase.

This is Andrej Karpathy's LLM Wiki

pattern, run as a team service. The idea: don't RAG over raw documents — where the model

rediscovers everything from scratch on every question — have agents compile sources into

structured, interlinked markdown entity pages (people, companies, projects, decisions) so

knowledge compounds. Vexa builds that wiki for you from the richest source there is: your

meetings. Each call is ingested into entity pages; agents keep them current between calls; every

answer starts from what your team already knows — on your own servers.

Agents work *any* workspace; a meeting is just one trigger of four — chat, schedule (cron), event (e.g. incoming email), finished meeting. Meetings themselves are scheduled work: connect your calendar (ICS) and planned meetings appear with attendees — bots auto-join, agents prepare before the call and process after it.

• Multiplayer. Team-shared, attributed workspaces — not one person's private notes.
• Automated. The bot captures the call; the transcript compiles itself in.
• Safe by design. Agents are untrusted and enforce nothing themselves. You, in chat, write directly (git is the undo); untrusted input — an email, a web page — runs propose-only: the agent suggests, a human approves, trusted code applies. Irreversible effects are always gated.

Status (honest): capture, transcription, and speaker attribution are production; the

agent dispatch core is built and proven live end-to-end. What's still landing is tracked in

Status.

---

🖥️ The Terminal: AI-augmented meetings

0.12 ships a new Terminal UI built to put the backend's scale — thousands of bots and agents — to work on your actual week. It opens on your meetings: coming up, live now, to review.

• An agent in your meeting, with your knowledge. Open a live call: the transcript streams speaker-attributed, and the agent has the live conversation *and* your workspace in context. Ask mid-call "what did we promise them last time?" — or research a person, company, or contract the moment it comes up, grounded in your wiki.

• Knowledge built on meetings — and between them. Every planned meeting gets an agent that prepares the brief before (who's coming, history, open threads — it interviews *you* for what it can't know) and processes the transcript after. Arrive prepared, leave with the wiki updated.

• Sharing. Invite colleagues into a workspace — same wiki, attributed. Share a meeting with its attendees — they get the real-time feed, not a recording link after the fact.

• Collaborative, AI-augmented meetings. Prep a shared workspace together; during the call, humans edit the brief while agents stream the transcript in and work the knowledge — one room, human and AI participants on the same files.

---

📖 How-to recipes

Each is a complete path to one outcome over the Agent API. Full guides at docs.vexa.ai.

💬 Chat with your workspace — ask an agent that has every meeting, email, and note as context; trusted chat can also record a decision (a git commit).

curl -N -X POST "$API_BASE/age