vibecodeCLI

The agentic data engineering and coding CLI. Point it at your codebase and your warehouse alike: it grounds itself in your real schema and dbt lineage before writing a line of SQL, races N parallel agents across isolated git worktrees on every coding task, and an outcome-aware safety gate predicts what an action will do and rejects the dangerous ones, even in full-auto mode.

The CLI is free. Bring your own API key and pay your model provider directly, at cost. Your code never leaves your machine, and with credential-local execution your warehouse credentials never leave it either.

Built in Rust by ThinkingDBx.

Install

npm install -g vibecodecli
vibecodecli

Or try it once with no install:

npx vibecodecli

Prefer a direct install with no Node dependency:

curl -fsSL https://vibecodecli.com/install.sh | sh

Both paths deliver the identical binary and self-update the same way.

About this package

This npm package ships no application code. It is a thin, integrity-checked downloader: on install it detects your platform, fetches the prebuilt native binary for this exact version from vibecodecli.com, verifies its SHA-256 checksum against the published manifest, and only then places it on disk. The launcher on your PATH simply executes that verified binary.

Supported platforms: macOS and Linux, on x64 and arm64. Windows is not yet supported; installing there fails fast with a clear message rather than leaving a broken half-install.

Quick start

vibecodecli                                   # interactive session
vibecodecli run "fix the failing test"        # one-shot, streams live
vibecodecli run --agents 4 "make it faster"   # fleet: 4 isolated agents
vibecodecli run --agents 3 --mix "your task"  # bake-off across your providers

On first run it asks you to pick a provider and paste a key. 25 providers are built in (Anthropic, OpenAI, Gemini, Grok, Mistral, DeepSeek, Groq, Cerebras, Ollama and more), including keyless local servers such as Ollama and vLLM.

What it does

Parallel fleet

Fan out N autonomous agents on the same task, each in its own git worktree, so they run truly concurrently without colliding. Each agent can run a different model: pick per agent in the guided wizard, pass an explicit list with --models provider:model,..., or let --mix distribute your keyed providers automatically for a model bake-off. A live dashboard shows one enlarged focused pane plus a compact strip per agent, with per-agent status, retry notices, elapsed time and tokens. From the dashboard you can inspect a finished agent's colorized diff, cancel or rerun an agent, and when the fan-in review posts its recommendation, land the winning branch without leaving the screen.

Data engineering

Connect a backend with the guided /connect picker and the same agent gains a data engineering toolset. It introspects real schemas, reads dbt lineage to answer blast-radius questions before anything runs, previews query plans and cost before a write executes, and materializes models with a live per-stage pipeline board. Fifteen connectors cover PostgreSQL, MySQL, SQL Server, Snowflake, BigQuery, Databricks, Redshift, ClickHouse, DuckDB, SQLite, MongoDB, Redis, Apache Iceberg, S3 and SFTP. With a credential-local connection, an embedded runner executes queries on your machine, so the cloud orchestrates the work but never sees a password. In a fleet, writes to shared external state are deferred so parallel agents never collide on one warehouse.

Long-term memory

Connect ThinkingMemory and the session remembers across restarts: each turn recalls a ranked, token-budget-packed slice of relevant history and remembers the turn's outcome. Recall is visible (a per-turn receipt shows what entered context and what it saved), fenced as untrusted data so a stored memory cannot smuggle instructions, and budget-adaptive so a casual greeting does not spend what a real task deserves.

Safety and autonomy

An autonomy dial (careful, auto, full-auto) decides what gets confirmed. Before any action that touches external or irreversible state, a forward check predicts its concrete effect and proceeds, defers to you, or rejects it outright. A predicted-unsafe action is rejected even in full-auto. Every turn snapshots the files it touches, so one keystroke reverts. Content fetched from the web or returned by third-party tools is fenced as untrusted data, secrets at rest are written owner-only, and the SSRF guard pins vetted addresses so a hostile page cannot steer requests at internal services.

Cost control

Prompt caching keeps the growing transcript cheap, old tool output is compacted automatically, connected MCP servers can be muted per session with /mcp to reclaim the prompt tokens their tool schemas cost, and if a request ever exceeds a small model's context window the CLI sheds optional context and retries instead of failing.

The ThinkingDBx stack

vibecodeCLI is the terminal front end of a small, composable data and AI stack. Each piece is optional; the coding agent works fully on its own.

• ThinkingDBx, the company: a data and AI startup building the backbones an agent needs to work your whole data stack. https://thinkingdbx.com
• ThinkingMemory, the cloud memory backbone: long-term, per-repo recall so the agent stops forgetting across sessions. https://memory.thinkingdbx.com
• ThinkingLanguage (TL), the cloud data engine backbone, powered by Apache DataFusion: runs SQL and cross-source pipelines in the engine, never through the model, so big data never flows through an LLM. https://tl.thinkingdbx.com

Links

• Documentation: https://vibecodecli.com/docs.html
• Homepage: https://vibecodecli.com
• Changelog: https://vibecodecli.com/changelog.html

Free to use. Terms: https://vibecodecli.com/terms.html

Questions or feedback: [email protected]