How a SaaS Startup Replaced 3 Internal Tools With One AI Agent

A 40-person SaaS startup was running their operations across three separate internal tools: a custom Retool dashboard for customer health scoring, a Zapier-powered ticketing router, and a Google Sheets workflow for renewal tracking. Each tool had its own logic, its own maintainer, and its own set of failure modes. When the person who built the Retool dashboard left the company, nobody could update it. When Zapier hit rate limits, tickets sat unrouted for hours. When the renewal spreadsheet got too large, it crashed every time someone opened it.

They came to us not asking for AI. They were asking for help cleaning up the mess. AI just happened to be the right answer.

The Three-Tool Problem

Each tool had been built to solve a real problem. The issue wasn't that they existed. It was that they existed independently.

Tool 1: Customer Health Dashboard (Retool)

The dashboard pulled data from Stripe, Intercom, and their product database to generate a health score for each account. Green meant happy. Red meant at risk. In theory, the customer success team checked it daily and reached out to red accounts.

In practice, the dashboard loaded slowly, the health score algorithm was undocumented, and the CS team had stopped trusting it after it flagged three healthy accounts as "critical" in the same week. Usage had dropped to 2-3 people checking it sporadically.

Tool 2: Ticket Router (Zapier)

Inbound support tickets came through email and in-app chat. A Zapier workflow classified them by keyword matching and routed them to the right team: billing, technical, or product feedback. It worked for simple cases. But keyword matching doesn't understand context. A ticket saying "I love the new billing feature but the export is broken" would get routed to billing instead of technical. Misrouting rate was running at 23%, which meant nearly 1 in 4 tickets needed manual re-sorting.

Tool 3: Renewal Tracker (Google Sheets)

A master spreadsheet tracked every customer's contract dates, renewal status, and next steps. The account management team updated it manually after every customer interaction. Rows got missed. Dates got entered wrong. Two people would update the same row and overwrite each other's notes. The sheet had 2,400 rows and took 45 seconds to load.

The total cost of maintaining these three tools: an estimated 62 hours per week across the CS, support, and account management teams. Not building new things. Just keeping the existing systems from falling apart.

The Single-Agent Solution

We proposed replacing all three tools with one AI agent that could handle customer health monitoring, ticket routing, and renewal tracking as a unified system. The key insight was that these weren't three separate problems. They were three views of the same problem: understanding customer status and taking the right action.

Architecture

The agent connected to five data sources:

• Stripe for billing status, payment history, and plan details
• Intercom for support ticket history and conversation sentiment
• Product database for usage metrics, feature adoption, and login frequency
• CRM for contract dates, renewal terms, and account owner assignments
• Slack for delivering alerts and receiving team commands

Instead of three tools checking three slices of data, one agent had the complete picture.

Customer Health Scoring

We replaced the undocumented Retool algorithm with a transparent scoring model. The agent evaluated each account across four dimensions:

• Product engagement: Login frequency, feature adoption, time spent in-app
• Support sentiment: Ticket volume trend, resolution satisfaction, conversation tone
• Billing health: Payment failures, plan changes, discount usage
• Relationship signals: Response time to CS outreach, meeting attendance, NPS scores

Each dimension produced a 1-10 score with a plain-language explanation. No more mysterious red/green dots. The CS team could see exactly why an account was flagged and what specific signal triggered the alert.

The agent ran health checks every 6 hours and proactively messaged the account owner in Slack when a score changed meaningfully. No more checking dashboards. The information came to the team.

Intelligent Ticket Routing

Instead of keyword matching, the agent read the full context of each ticket and made a routing decision based on:

• The actual topic (understanding context, not just keywords)
• The customer's current health score and recent history
• The ticket's urgency based on language and business impact
• Which team member had the most relevant context for this specific customer

A ticket from a red-flagged account automatically got priority treatment. A billing question from a customer whose renewal was 30 days out got routed to the account manager, not just the billing team. The agent understood that these weren't isolated events. They were connected data points.

Renewal Management

The spreadsheet died. The agent tracked every renewal date, calculated days-to-renewal, and triggered a structured workflow:

• 90 days out: Agent generates an account summary for the AM, highlighting usage trends, support history, and risk factors
• 60 days out: Agent drafts a personalized renewal outreach email for AM review
• 30 days out: If no engagement, agent escalates to the CS lead with a risk assessment
• 14 days out: Daily Slack reminders with specific talking points based on the customer's recent behavior

No more missed renewals because someone forgot to check row 1,847 in a spreadsheet.

The Build Process

Total timeline: 6 weeks from kickoff to production.

Weeks 1-2: Discovery and data mapping. We mapped every workflow, interviewed every team member who used the existing tools, and audited the data quality across all five sources. We found that 15% of CRM records had incorrect contract dates, so we built a reconciliation step into the agent's startup routine.

Weeks 3-4: Core agent development. Built the health scoring model, ticket routing logic, and renewal workflow engine. Ran parallel testing against historical data: fed the agent 3 months of past tickets and compared its routing decisions to what humans actually did.

Week 5: Supervised launch. The agent ran in production but all actions required human approval. The CS team reviewed health alerts before they went out. The support team confirmed routing decisions. This built trust and caught edge cases.

Week 6: Graduated autonomy. Based on week 5 performance, we moved ticket routing to fully autonomous (the agent's accuracy exceeded the human baseline). Health alerts and renewal workflows stayed in a review mode for another two weeks before going fully autonomous.

Results After 90 Days

Ticket routing accuracy: 94% (up from 77% with keyword matching). The remaining 6% were genuinely ambiguous cases that the agent flagged for human decision.

Renewal coverage: 100%. Zero renewals missed or forgotten. Previously, the team estimated they were catching about 85% on time.

Time saved: 62 hours/week reduced to 11 hours/week. The remaining 11 hours were high-value activities: actual customer conversations, strategic account planning, and reviewing the agent's weekly performance reports.

Net revenue retention improved by 8 percentage points in the first quarter after launch. The team attributed this primarily to earlier identification of at-risk accounts and more consistent renewal outreach.

Tool maintenance dropped to near zero. One person spent about 2 hours per week reviewing the agent's performance metrics and adjusting scoring weights. Compare that to the three part-time "tool maintainers" the old system required.

What Made This Work

Three factors separated this from a typical automation project.

1. Unified data, not unified UI. We didn't build a new dashboard that combined three data sources. We built an agent that understood all three data sources and took action. The team's "interface" was Slack, a tool they already lived in.

2. Graduated autonomy. Starting with human-in-the-loop for every action built trust. By the time the agent was running autonomously, the team had seen it make hundreds of correct decisions. They trusted it because they'd verified it, not because we told them to.

3. Transparent reasoning. Every action the agent took came with an explanation. "Routing this ticket to Sarah because the customer mentioned API integration issues and Sarah resolved their last API ticket 3 days ago." The team could audit any decision in seconds.

If your operations are spread across multiple tools that don't talk to each other, the answer probably isn't a better dashboard. It's a system that understands the full picture and acts on it. That's what we build.