Meet io

Human-agent collaboration

Most "AI agent builders" are a chat box bolted onto a configuration screen. You type what you want, a model guesses at some JSON, and you spend the next hour fixing what it got wrong. We took a different path with io, our agent for building with Vectara. We’d like to share the design decisions behind io, because they make the difference between a demo that wows and a tool that ships.

The essence of how it works:

1. You describe what you want in words that come naturally to you. No expertise with Vectara required
2. io infers your intent (asking for clarification when needed), inspects the resources you already have, and wires up the agents, pipelines, tools, and corpora you need.
3. As it works, it shows you what it’s doing, makes suggestions, and asks for input. You can step in and make adjustments at any time.

AI that reads your mind

One early internal tester summed up the feeling better than any spec could: it's like using Cursor, but it’s Vectara. Cursor earned a devoted following by embedding an agentic framework inside the IDE, anticipating what developers are trying to build and doing the heavy lifting before they ask. And that's exactly the bar we set for io. Its not just a Q&A bot that explains the docs to you, but a domain-expert copilot that operates the platform on your behalf guarded by your intent.

At Vectara, we rely on our agentic platform in every function of the business. io is no exception: it's built on the exact same runtime, REST API, and tool primitives we ship to our enterprise customers. Nothing about it is privileged or special-cased. io provisions its own API key on load and calls the same endpoints any customer's agent would.

Infinite flavors of agent

The hard part of an agent builder is the sheer size of the surface area it must support. The set of things people will ask io to build is effectively infinite, and so are the ways they'll phrase those requests. That makes it the single highest risk component in the product, because you can't manually test your way to confidence. There's no unit test for "the model got confused."

So reliability can't be a layer you add at the end. It has to be engineered into the agent's structure from the start, and it has to be measurable. Three decisions came out of that principle.

Plans change

The intuitive fix for a confused agent is to give it a "planning mode". The agent forms a plan and then executes the plan. But there’s a critical flaw in this approach: no plan survives contact with reality. The best plans evolve over time and incorporate lessons learned. Planning mode forces the agent to spend much of its session defending a bad guess.

A better approach is to enable the agent to amend its plan with new information and correct invalidated assumptions. We implemented this by giving io a “scratchpad”. By combining this with its ability to ask structured clarifying questions, it’s able to learn new facts, record them, and develop requirements hand-in-hand with the user.

Disambiguation by design

Here's another subtle failure mode we ran into. io is deeply educated on Vectara's own documentation… so deeply in fact, that it started thinking users were talking about Vectara docs any time they mentioned “docs”, even if they clearly meant their own! The lesson generalizes: an agent steeped in one context will silently assume that context is shared.

We solved this by making disambiguation an explicit instruction, not a hope. io is told that users don't share its frame of reference. It probes ambiguous references: confirming which corpora you mean (or need to create), or checking whether an existing agent could serve as a template before generating a new one. Making assumptions is a bug. Asking questions is a feature.

Self-grounding enables self-correction

io answers from Vectara's documentation and its own workspace. It’s aware of the agents you already have set up, their live performance and your configured data pipelines. Most importantly, it uses the live API and knows how to independently correct mistakes. When io gets a request shape wrong, the API tells it so. io reads the error and decides: ask the user, or safely correct it on its own. We watched it wrestle with a tricky workflow agent, one connecting several enterprise systems to manage IT requests, work through the errors methodically, and land the build. That self-correction loop is the agentic pattern doing what it does best: turning a brittle one-shot into a resilient process.

The power of io’s grounding is that it works through all available data, even historical data from the agent’s performance. You can point io at an agent’s past session and ask it to explain and diagnose the behavior in detail. For example, you might ask why your customer support agent raised a ticket instead of referring to the knowledge base and forming an answer. io traces the agent's path, the tools it called, how long each step took, and whether each succeeded. Then it proposes concrete improvements to the agent's configuration. io translates an opaque transcript into a diagnosis, and develops your entire agentic setup in minutes.

Two architectural bets

We made two big bets in designing io’s architecture, and each one is derived from our fundamental belief that io must use the platform the way a customer would instead of having access to private shortcuts.

Sharing a workspace

Vectara provides you an entire UI for working with our platform. People use forms, tables, reports, code snippets, and dozens of purpose-built features to understand the state of their work and to express their intentions. For io to truly collaborate, it needs to meet you where you’re working. So that’s what io does: it can read the forms you’re editing, suggest improvements directly inline, and act on the UI just like you do.

Teach an agent to connect…

Traditionally, applications have enabled access to data in external services like Jira, Google Drive, and Box by providing a set of service connectors. We took one look at that, had a fever dream about giving someone a fish and eating for a day, and we set off in a very different direction.

We configured io with a generic API tool that it can control by tweaking parameters and transforming responses. Authentication is handled via agent secrets. This tool gives io the power of traditional connectors, with none of the traditional maintenance burden. The payoff is leverage: io’s access to external data grows over time without a queue of connector engineering behind it. This is a deep topic that we’ll explore further in further blog posts.

Try io today

With io, the barrier to building enterprise agents evaporates. To get started, all you have to do is tell io what you want. Want to learn how to do something? Just ask io and it will show you how. io is available in every Vectara account, starting today.