u/Financial_Ad_7297

I've noticed that different teams seem to judge AI customer support systems in completely different ways.

Some care about deflection rate. Others look at average handling time, first response time, CSAT, first contact resolution, or simply how much support costs have come down.

The problem is that improving one metric doesn't always mean the overall experience is better. An assistant might deflect more tickets, but if people keep reopening them or immediately ask for a human, that number doesn't say much on its own.

If you could only track one or two KPIs to judge whether an AI support system was actually doing its job, what would you choose?

I'd be interested to know whether your answer changes depending on the type of support team or industry.

Debugging LangGraph workflows has been a lot less straightforward than I expected.

When the final output is wrong, the actual issue usually isn't where I first look. It could be retrieval, a slow or failing tool, an unexpected branch, or state changing somewhere earlier in the graph.

By the time you notice something's off, the root cause can be several steps back.

For those running LangGraph in production, what's your usual starting point when you're debugging?

Do you look at execution traces, tool calls, token usage, or something else that's consistently helped you narrow things down?

Something I didn't expect from all this agent work is how often I stop thinking about the human using the software.

A lot of the interfaces being built now aren't really meant for people. They're meant for agents.

Instead of clicking through dashboards, the agent calls an API. Instead of reading a paragraph, it gets structured data. Instead of navigating a UI, it works with tool schemas and permissions.

And that got me wondering if we're heading toward a world where a lot of business software is designed with agents as the primary user and humans as the supervisors.

If that happens, I wonder how much software design changes. Do dashboards become less important than APIs? Do we spend more time designing reliable tool interfaces than polished UIs?

Am curious whether other people have started thinking about this too, or if I'm reading too much into where things are heading.

Most conversations about building agents seem to revolve around models, prompts, RAG, memory and tool calling.

Then you try to get one running reliably outside of a local setup and suddenly you're dealing with retries, queues, permissions, logging, rate limits, tracing, rollbacks and a bunch of other stuff you barely thought about when you started.

For anyone who's actually put agents into production, what ended up being the infrastructure problem you underestimated the most?

Also, did you find decent tooling for it, or did you eventually give up and build something yourself?

Just tech specs ni compare cheskunna melody is beating most of our IMAX screens. So India lo IMAX ki poinollu evaraina cheppandi. Is the comparison really accurate?

For a while I assumed AI agents for lead generation were mostly about automating cold outreach.

After digging into how companies are actually using them, I think that's only a small part of the picture.

The biggest value seems to come from all the work that happens before and after someone replies.

Things like researching accounts, enriching contact data, figuring out who the right person is, drafting an email based on what's publicly available about a company, replying quickly when someone fills out a form, following up consistently, and keeping the CRM updated. None of those tasks are particularly difficult, but they add up.

I also came across a startup that reportedly used its own AI agent extensively during its Series A fundraising process to research investors, personalize outreach, coordinate follow-ups, and manage parts of the pipeline. That caught my attention because it's a very different use case from traditional sales prospecting.

From what I've seen, AI isn't replacing the person selling. It's reducing the amount of repetitive work around selling, so people spend more time talking to qualified prospects instead of doing admin.

Of course, it isn't hands-off either. If the data is poor or the workflow isn't designed well, the results fall apart pretty quickly. Someone still has to review what the agent is doing and make sure it's representing the business properly.

I'm interested in hearing from people who've actually put this into production.

Have AI agents changed the way your team handles lead generation, or are they still mostly a nice demo? And where have you seen the biggest payoff: prospect research, outreach, qualification, follow-ups, or somewhere else?

I've been seeing more companies move beyond AI copilots and start talking about AI agents that can actually take actions inside a CRM instead of just answering questions.

On paper, it sounds useful. Updating records after calls, qualifying inbound leads, drafting follow-ups, summarizing meetings, routing tickets, creating tasks, or kicking off workflows without someone clicking through everything manually.

But I'm more interested in what happens after the pilot.

Has anyone here actually rolled this out and kept using it?

What platform did you go with? I've seen Salesforce Agentforce, HubSpot Breeze, Microsoft Copilot, Zoho's AI, Lyzr, and a few others, but it's hard to tell which ones are delivering real value versus nice demos.

Did it actually reduce admin work for your sales or support team? Were there things you expected it to do but still needed people for? And how much time did you spend getting your CRM, permissions, and workflows into a state where the agent was actually useful?

I'd rather hear from people who've lived with these tools for a few months than read another vendor case study.

https://preview.redd.it/0fsrqnjc6fch1.png?width=1270&format=png&auto=webp&s=adc7cde3e73e0260a431dbd2c13a64a4808310dc

Saw this on TechCrunch. Assuming that the report is accurate, this is an interesting example for how capable AI agents are in these business workflows too.

Most discussions around AI agents still end up being about frameworks and models. LangGraph vs CrewAI, which model has better tool calling, prompt engineering, that sort of thing.

But I don't think building agents is the hard part anymore.

The tooling has improved so much over the last year that getting an agent working isn't nearly as intimidating as it used to be. What's starting to matter more is everything that comes after.

How do you deploy updates without breaking something? How do you test changes before they reach production? How do you keep track of which version is running where? What does rollback look like? How are permissions, approvals, and audit logs handled when you have multiple agents doing different jobs?

Software engineering eventually settled on pretty standard ways of handling all of this. With AI agents, it still seems like every team is piecing together its own solution.

So I'm wondering what people are actually doing today.

Are most teams building their own internal tooling around the framework they've chosen? Is there already a category of tools solving these problems that just doesn't get talked about as much? Or is this still one of the biggest gaps in the ecosystem?

Spent the last few weeks going through documentation, pricing pages, customer case studies, analyst reports, review sites, and comparison articles while shortlisting AI customer support platforms.

1. Intercom Fin
Probably the strongest choice if you're already on Intercom. It works across messaging, chat, and email without relying on traditional decision trees, and Intercom publishes resolution metrics that can help teams estimate ROI before rollout. Escalations carry the full conversation history into the Inbox, making human handoffs much smoother than many earlier AI support tools.

The biggest tradeoff seems to be pricing. Fin charges roughly $0.99 per AI resolution, which is straightforward at lower volumes but can become harder to forecast as automation increases.

2. Zendesk AI
The obvious choice for teams already invested in Zendesk. It sits directly inside the existing ticketing workspace with intelligent triage, agent assist, and automated resolutions, so there's very little operational friction if you're already using the platform.

Where it seems to become more expensive is the pricing model. Suite plans have per-agent costs, AI resolutions are billed separately above committed usage, and Copilot functionality is an additional add-on. For organizations with high ticket volumes, the total AI spend can grow well beyond the base subscription.

3. Lyzr AI
The thing that felt good to me was it wasn't just a chat bot, it's structured as separate agents (email triage, phone support, CRM case generation) that share context instead of one bot trying to do everything. Email triage sorts the inbox before anyone opens it. Phone support hands off to a human mid-call with transcript intact. CRM case generator auto-fills fields from the interaction. Model-agnostic, so it's not locked to one LLM. Setup took longer than the plug-and-play options here since it's not just a widget.

4. Lorikeet
One platform that stood out because of its focus on regulated industries like fintech, healthcare, and insurance.

Instead of only answering questions, it emphasizes end-to-end resolution across chat, email, voice, SMS, and WhatsApp while maintaining audit trails for every interaction which matters in compliance-heavy environments.

Its per-resolution pricing model also seems relatively straightforward, and public documentation notes that escalated conversations aren't billed as AI resolutions, which is an interesting approach compared to some competitors.

5. Ada
Enterprise-focused, connects to CRMs, billing, and commerce tools to resolve multi-step issues (not just answer questions) across chat, email, voice, SMS, and social. Speaks 50+ languages out of the box, which mattered for us more than I expected once support tickets stopped being English-only. No-code setup, but pricing is custom and volume-based, so budgeting takes an actual conversation with sales rather than a pricing page.

Most underwriting teams seem to have adopted some form of AI at this point, but I wanna know what it's actually been like once you're past that pilot phase and into real day to day workflows.

What surprised you in a good way? And on the flip side, what ended up being more of a headache than it was worth?

Mainly asking about document intake, income and asset verification, fraud detection, condition generation, exception handling, and loan summaries, but if you've seen value pop up somewhere unexpected, I wanna hear about that too.

Also, which vendors or platforms have actually held up once you're running real volume through them? There are a hundred options right now and it's tough to tell what's legit versus what's just good marketing.

Building an agent has become much easier now. Half the frameworks out there get you a demo in a day, sometimes less.

The hard part is everything that comes after. Versioning, deployment, environment management, monitoring, rollbacks, access control, all of it. We learned this the hard way after our first pilot actually worked and we had no plan for what came next.

Anyone here actually made it past the pilot stage? What broke first for you and what do you wish you'd set up earlier instead of scrambling later?

Building one agent isn't the hard part anymore. Half the frameworks out there can get us the perfect demo in just hours.

But what nobody talks about is the part that comes months after the demo.

Our team hit this wall a while back. Prototype worked great, everyone was hyped, then we tried to actually run it in prod and realized we had zero story for several things.

Versioning: What happens when you tweak a prompt and suddenly three downstream workflows break in ways nobody predicted.

Deployment: Rolling out an agent update feels nothing like rolling out a normal app update. The blast radius is weird.

Environment management: Dev vs staging vs prod behaves differently when your "code" is partly a prompt and partly a model that can just decide to do something else.

Monitoring: Normal APM tools don't tell you why an agent made a dumb decision. You need to see the actual reasoning trace, not just latency and error rates.

Rollbacks: Rolling back code is easy. Rolling back "the agent used to behave this way and now it doesn't" is a different beast entirely.

Access control: Who's allowed to change what an agent can do, especially once multiple teams are building on top of the same agent infra.

Anyone here actually gone past the pilot stage and lived to tell about it? What broke first for you? What did you wish you'd set up before scaling instead of after?

I've had this query for a while. So you tweak a prompt and run it a few times. If the outputs look better, then you ship it. But how do you actually know that wasn't just a good run 'cause same prompt could've looked worse if you ran it five more times.

What I feel is that a lot of teams don't have a real answer for this beyond a handful of manual spot checks, which is fine when you're early, but that starts feeling shaky once actual users are depending on the thing not randomly falling apart.

What's included in your actual evaluation process? Is it Running the same input multiple times and checking variance or keeping a fixed eval set?

Same set of tools get recommended everywhere. LangSmith for tracing, LangGraph for orchestration, FAISS or Chroma for vector stores. Maybe Langfuse if someone mentions they want an open source alternative. And that's where it kind of ends.

But imo there's a lot of genuinely useful open source stuff built around Langchain that just never surfaces. Custom memory implementations, retrieval pipelines, callback handlers, agent frameworks that sit on top of Langchain and actually solve specific production problems. The kind of stuff you only find if you're deep in GitHub at 3am or someone mentions it offhand in a thread. Part of the problem is LangChain moves fast enough that half the community tooling is either undocumented or already outdated by the time anyone finds it.

What's one open source LangChain tool or library you actually use and think nobody knows about?

This is how I'd rank the six screens purely based on my experiences.

1. Screen 4

2. Screen 1

3. Screen 2

4. Screen 3

5. Screen 6

6. Screen 5

Even tho s4 doesn't offer atmos, the picture quality outshines both screen 1 and 2. Watched backrooms in that screen recently and the sound and picture quality felt better than screen 2 where I watched Dhurandhar 1.

Spent more time last week setting up orchestration, evals and observability than actually building the thing i wanted to ship. And I feel the ecosystem moved fast. The tooling kinda didn't. Nobody's stack is really one clean thing right now, everyone's duct taping something together and nobody looks very happy about it.

what's everyone actually running these days?

Back in the day every startup was building some version of a generic AI copilot. And the pitch was always the same. One agent to rule them all, works for every team, every use case.

But I feel that's not really what's happening anymore.

The market is quietly fragmenting into something way more specific. You've got companies like 11x and Artisan going all in on sales. Decagon and Sierra doing support. Moveworks is focused on the IT automation space. Glean is doing knowledge. And then there's a whole other category of platforms like Lyzr, Relevance AI and others that are less "we replace your SDR team" and more "build whatever agent your enterprise needs."

And most people talk about all of these companies as if they're in the same market. They all use the same buzzwords, they show up at the same conferences, and write the same thought leadership. But the actual problems they're solving are completely different. Different buyers with very different workflows.

Now it's just the SaaS market playing out again. We went from generic productivity software to CRM software, support software, HR software, IT software. Now we're doing the same thing but with agents.

The part that I am interested in is what happens next. Do the vertical players get so entrenched that horizontal platforms never get a real foothold, or does some layer eventually emerge that all of these get built on top of?

Not sure which way it goes. But that feels like the real bet being made right now across the whole space.