Chat and citations won't save your vertical AI - Atul Ramachandran, Filed Inc

Chat and citations won't save your vertical AI.

I'm sure many of us are building products in a vertical industry—be it healthcare, legal, or taxes—and usually doing so we sell one promise to the customers: either we're going to save you money or save you cost. And usually the pitch goes, "AI agents are here, they will do the work for you while you sleep."

Now, primary interface that we use for this are chat and citations to interact with an AI agent,right? Chats are usually used for inputs; they allow you to be flexible, you can talk to the agents as you please, while citations are usually used for outputs; they allow you to see the results, verify the results, and so on.

Now, I'm here to tell you that citations in chat alone will not allow you to keep the promise that you made to the customers—the promise of, you know, saving time and money for them. So who am I? I'm Atul, I'm the CTO and co-founder at Filed.

I've been fortunate enough to build products for more than a decade now. At Filed, we build products for tax professionals in the U.S., we have raised more than $17M to do so, and about 2 years now doing this, we have seen massive growth in the space.

Just to give you an idea, just last month we closed more revenue than what we have done in the 1 year alone before that. So the growth has been tremendous, and we're very excited for this. Doing this entire journey for the last 2 years, we have learned quite a bit, you know, and I think most of the learnings of building these AI agents for the taxes industry is essentially transferable to any other agentic product.

Now, chat is great. Like, it allows us to build fast, it allows customers to interact with products in ways that were not previously possible. It's a communication platform,right? You can interact with agents to do tasks, flexible tasks that were not constrained to the UIs that you have built.

Citations are also amazing; they ground the answers in truth. Other than allowing the users to verify the outputs, they also serve another purpose: they allow the agents to essentially be more accurate. Because now they are forced to, you know, present the references to their answers.

Agents perform much better with citations, so they reduce hallucinations, essentially.

But there's a key problem here,right? Chat is synchronous. If you think about it, even when you're coding, let's say you're using Claude Code, as soon as you're typing the request, once the request is typed, you're waiting for the agent to respond.

This synchronous medium does not allow the customers to leave the platform and go and do their work. Similarly, citations also put the verification burden back into the customer. So think about going and reviewing the agent's work now, one by one, to ensure everything is correct.

Especially in vertical industry space, like healthcare, legal, and taxes, this becomes very crucial. Because now this adds an extra work, and customers usually complain, you know, the promise of, you know, agents doing the work for me while I sleep is not really kept here.

Now, before we dive in, I want to take you through a brief history of how products have evolved. Specifically, I think there are 3 levels of abstractions, I would call it. So let's imagine a bank, to make it easier.

Let's imagine a bank. The banks used to have a physical presence before. You would go to a bank branch, you would take the money out by talking to an employee of the bank,right? And the point here was, the person who is doing the task is the employee of a particular company.

So you, as a user, would go in, you would delegate a task to an employee, they would do the task for you, and then, you know, come back with the result. Be it withdrawing money, or seeing how much balance you have, and so on.

Now, this essentially meant the bottleneck was the number of users, the number of employees that a company had. That's the bottleneck for creating value,right? Now, as time progressed, digital transformation era came. Basically, banks became online. You could—now the users can essentially open up the mobile app or the online portal and can make the transactions themselves, can actually go and see the balance themselves.

This was great. Because now the bottleneck moved from the number of employees a company had to the number of users that the company had. The more users, the more value you can generate. Now I think we have reached the point of another transformation layer called agentic delegation.

So no longer the users are coming in your product to use your product, I think they're coming to delegate more and more work to AI agents to do. So the point here is, if a user comes to your product and starts delegating work, long-running work, what would happen here is the bottleneck of number of users also goes away.

So it's no longer the amount of value that you generate is the amount of—the number of times the user has visited your platform. Because agents can do the work while the users have gone to sleep, you know, have delegated the task and went off.

So the bottleneck has shifted, meaning you can generate more value than ever before for your customers. Okay, so to make it easier, you can think of a product, your agentic product, as a conveyor belt, you know, and the user is the supervisor of the conveyor belt.

So think of it this way: previously, in a conveyor belt, usually there's a number of tasks that are happening, there are workers who are doing the work for you, and there's a supervisor who is delegating the task, you know, and monitoring how the things are going.

Similarly, now AI agents are your workers in that conveyor belt, while, you know, the conveyor belt and the entire infrastructure around it is your product. So users can come in, who is the supervisor, can come into the product, can start delegating tasks to the agents.

And this would mean it would give you an idea of what are the tools that you need to build in your product to make this happen. So that the agents can do the work and the supervisor or the user is, you know, pretty confident that the work is happening.

Alright, so how do we build this conveyor belt? So think of this this way. Like, when you're trying to build a product feature, think if a user wants to delegate a task, instead of doing it themselves in your platform, what would that interface look like?

Essentially, design for delegation, not participation. Now, to keep it more concrete, I think there are 4 key pieces when building an agentic product. And there are 4 key features or components that you need to have so that this conveyor belt that we're imagining can work.

So first thing is the easiest one. You need to find the task to delegate. The tasks that are coming in the conveyor belt are delegatable,right? And that can generate value for users. Second is, you need ability for users to teach the agents of, you know, the supervisor should be able to come and teach how the work needs to be done.

And lastly, there's no point of a conveyor belt where you cannot monitor the work yourself,right? And, of course, intervene when something goes wrong. Now, let's take delegation. So delegation means, you know, coming and handing over the task to another person,right?

So think of your users coming to your platform and delegating a task or handing off a task to an AI agent. So when building for this particular piece, you as a developer or a product engineer have to find tasks that your users do that take more than a couple of hours.

So in the case of taxes, there are like 3 different tasks that we have identified in your tax workflow, which take more than an hour for our users to perform. Similarly, in your industry, you can figure out, you know, which are those tasks.

It's important that these tasks are repeatable, or sort of repeatable, but differently applicable to each of their, you know, use cases. And these tasks are what you use to build what you call long-running background agents. This is where the core value is, you know, because you're taking off hours of work from your users' hands.

Awesome. So next is, you know, in any industry, in any professional industry, like in the case of coding, for example, everyone, every single user has their own preferences and have their own way of doing a task. An example is, you know, in coding, for example, every single company or every single group of developers have their own ways of dealing with best practices, their own conventions and practices that they follow.

So if you create a background agent, for example, and it does this end-to-end task of creating a product in the case of coding, for example, it will produce output, sure,right? It will get you mostly like 80 to 90% there.

But think of it this way. Like, that will not yet solve the problems of the user,right? As a user, you would want it to do it the way that you do the work. So this is where skills come into play.

Skills already exist in today's world of agentic development. So we need to ensure that your product also has skills in place to capture, so that you can teach your agents how your users do the work. This is the last 20% of the work that you need to take care of.

This is where the real value is, the quirks of the work, you know, that you're capturing. In our case, in taxes, we capture all of these skills automatically. You do not need to have, like, a complete separate interface where users will go and create skills.

That won't work. In many cases, you need to, like, look at the product usage and figure out whether you can create a skill for that particular use case or not. So we automatically do in our case. And a prime example that you would have used a product called WhisperFlow, they also have, like, automatic skills.

So you use and it keeps on learning as you use the product.

Now, monitor. Monitor is the key part,right? So since agents are long-running now, the whole point is there will be, like, multiple tasks that are running and the users need to keep track of what is happening in this world,right?

So one simple example here could be a task list that you can do to keep track of where the processing is for each of those tasks. And second example here is, like, building traces in your product, you know.

Trace how the agent did the work that it did. They're long-running tasks, so there will be multiple pieces that are moving. So you need to trace back. So in our case, we trace back each and every value that the AI agent produced in a particular, you know, in the format that the users can easily see.

This is where the trust is built. And this is where the visibility is built. So it's paramount that, you know, you build this correctly. This is where most of the complaints can be getting addressed to build thisright. And lastly, think of it this way,right?

Control. So when something requires a judgment, or when something goes wrong, your platform should inspire confidence that the users can take back control. This is critical because level 3 product, or the conveyor belt product that we're building, will allow your customers to, you know, schedule a lot of tasks.

But if they don't have the confidence that, you know, if something goes wrong, they can take back control,

then the users will completely lose trust. So it should feel like, you know, the users are taking the wheel, not abandoning the car and, you know, creating a new car, for example. So ideally, it should go like, you pass the belt, fix the problem, you start it back up again.

In our case, we could do it very simply by, you know, passing wherever the agent was trying to make an assumption. We pass, and then the users would come in, just like in Slack or any other chat platform.

They can come and tag the agent and respond with how to deal with that particular conflict.

Okay, some bonus points as well. So just as physical bank branches didn't disappear when the mobile banking arrived, or, you know, when the level 2 arrived, I don't think when the agentic layer approaches, it's an abstraction over the last 2 layers that, you know, all other mobile apps and things like that will disappear.

The point here is, a user will only come and delegate work to believe that, you know, they can always take back control. So first step is, you know, giving them the confidence that they can take back control, you know, when something goes wrong.

So you need to build level 2 features into your product as well. That's the key point here, to build trust. And second thing is, some actions are usually irreversible and are dangerous actions. And in those cases, you need to present a plan.

So think of it like, in case of bank transactions, for example, before making a bank transaction, the plan should be there, you know, if a certain amount of value is going somewhere else. Same way, in our cases, before we do data entry into a tax software, which can erase their existing data, we create a plan for them so that they can approve the plan before they move on.

These are the key pillars that allow customers to feel, you know, control and allow customers to feel as if, you know, if something goes wrong, they can take back control at any point in time. Okay, lastly, since we're building products now completely differently,right?

We are not building for the users to come in and use the product. We're building for users to come and delegate work. It's important that we change the way we measure this value. So the most popular metric that customers, that the products use today, are weekly active users.

Now, this was great in the era where, you know, people used to come and do the work in the platform themselves. But it doesn't really translate well with agentic delegation. So the point is, we have to change the way we measure.

And I think the appropriate measure here is weekly active sessions. I treat it as, you know, a task that is completed by a human or an agent, even when the user is not in your platform. So your actual aim should be the weekly active users go down, while weekly active sessions go up,right?

Because you want your users to have enough trust in your platform that they can come and delegate your task as much as possible, and those tasks are executed without a human help as much as possible. So the number of sessions should go up.

Weekly active sessions should go up, while the number of weekly active users in your platform should ideally go down. It should not be zero, of course, but it should go down.

So what are the key takeaways? The key takeaways are, first of all, design for delegation, not participation. Design your products in a way that users are coming into your product to delegate work, not do it themselves. Secondly, to make that possible, you need to think of your product as a conveyor belt.

So users are now the supervisors. They're not operators. They're coming here to delegate work and monitor, you know, figure out if there are problems, and then take actions. And finally, you need to change the way you measure how the work is done, not the time on the platform.

So weekly active sessions instead of weekly active users. If you keep these 3 in mind, you will be able to build a very successful vertical AI product, I think. Alright, thank you for your time, and good luck out there.