Why We Built Vanna 2.0

The Journey So Far

When we open-sourced Vanna, our goal was clear: become the default tool people reach for when they want to generate SQL using LLMs. We achieved that goal. With over 20,000 stars on GitHub, Vanna has surpassed and outlasted other options. Developers around the world choose Vanna every day for text-to-SQL generation.

What We Learned

The original Vanna was optimized for GPT-4 and single-user demos. While it continues to gain new users daily, it’s fundamentally a product of its era—built before we truly understood what production AI agents needed.

We learned three critical lessons from our enterprise customers:

1. User Identity Can’t Be Bolted On

Every enterprise customer asked the same question: “How do I make this work for multiple users with different permissions?” Most agent frameworks are built for single-user demos or operate in “global” scope. They simply don’t have multi-tenant isolation built in. Adding it yourself means building your own wrapper framework on top of the framework—you end up rewriting everything when you go from prototype to production.

2. LLMs and Humans Need Different Outputs

When a SQL query returns 10,000 rows, dumping that into the LLM’s context is a waste of tokens. But showing the user just “Query succeeded” is a waste of their time.

We discovered that tools need to return two things: a concise summary for the LLM (“Query returned 10,000 rows, here’s a sample…”) and rich interactive components for the user (full sortable data table with export).

Nobody else was solving this problem. Other agent frameworks focused on streaming text. But production applications need status cards that update, progress bars that fill, and artifacts that render externally—not append-only chat logs.

3. Enterprises Need the Full Stack

When an enterprise says “we want to self-host,” they don’t just mean the agent loop. They mean:

• Secure Python sandboxes for code execution
• Audit logs for compliance
• Quota management per user
• Row-level security for database access
• Conversation persistence with encryption
• LLM failover when Claude is down

These aren’t nice-to-haves. They’re table stakes for production. And every customer was building the same infrastructure from scratch.

The GPT-5 Moment

We’re at the threshold of GPT-5 class models—models with dramatically improved reasoning, longer context windows, and true agentic capabilities. But here’s the problem: most agent frameworks were designed for GPT-4’s limitations, not GPT-5’s possibilities.

Vanna 2.0 is our answer. It’s not an incremental update—it’s a complete rethinking of what an agent framework should be in the GPT-5 era.

Why Vanna 2.0 Exists

The core problem with existing agent frameworks is that they’re built for single-user demos or operate in global scope. Multi-tenant isolation is an afterthought, if it’s considered at all. This creates a gap between prototyping and production that costs months of engineering time and introduces security risks.

Identity-First Architecture

Every request in Vanna 2.0 carries user identity, permissions, and workspace context from the moment it enters the system until tools finish executing. User isolation isn’t something you configure—it’s impossible to build an agent without it.

Key Benefits:

• User context flows automatically to every tool
• Tools enforce their own permission logic based on user identity
• No manual plumbing required - it’s built into the framework
• Multi-tenant by design, not an afterthought

Dual-Output Model

Tools return results optimized for both LLM reasoning and user interaction. The LLM sees: “Query returned 1,247 rows.” The user sees: an interactive data table with sort, filter, and export.

This saves tokens, improves UX, and keeps your LLM context clean. No other framework does this.

Production-Ready from Line One

Unlike other frameworks where you prototype with one architecture and rewrite for production, Vanna 2.0 uses the same codebase from first prototype to multi-tenant production:

1. Prototype: Test with MockLlmService, no API keys needed
2. Add Tools: Register SQL, file system, or custom tools
3. Production: Add your real LLM, enable streaming, deploy as-is

No rewrites. No surprises. The same agent that works on your laptop scales to 10,000 users.

Beyond SQL

Here’s what we realized: there’s nothing about Vanna 2.0’s architecture that’s specific to SQL or databases. The identity-first design, dual outputs, and rich components work for any enterprise agent use case:

• Coding assistants that respect workspace boundaries
• Document Q&A that enforces document-level permissions
• Workflow automation with user-scoped execution
• Customer support with quota enforcement
• Data visualization that generates Plotly charts and dashboards

The technical foundation we built for SQL agents turned out to be exactly what enterprises need for any AI agent.

What We’re Not

We’re not trying to be:

• A low-code builder - You write Python
• A ChatGPT wrapper - We’re a framework for building your own agents
• SQL-only - That’s just one use case we happen to know well

What We Are

We’re the agent framework for enterprises that need to ship to production.

• Open source - MIT licensed, no vendor lock-in
• Identity-first - Multi-tenant by design, not as an afterthought
• Production-ready - Quota management, permissions, audit logs built-in
• Developer-friendly - Start in 5 minutes, scale without rewrites

The Road Ahead

We’re not anchored to SQL anymore. Vanna 2.0 is a platform for building any kind of enterprise agent.

Our roadmap:

• Launch Vanna 2.0 open source framework
• Launch Cloud Platform with premium features
• Enterprise VPC deployments
• First-party tools marketplace (Python sandboxes, RLS, failover)
• Ecosystem of community-built tools and templates

Join Us

We learned from older versions of Vanna. We listened to our enterprise customers. We saw where the market is heading.

Vanna 2.0 isn’t just a better version of what exists—it’s what should have existed from the beginning.

If you’re building AI agents for production, we built this for you.

Quickstart Notebook → Open in Colab → View on GitHub → Join Discord →