Thinking Agentically: The Problems You Didn't Know You Could Solve
by Tyler Vorpahl, Partner | CTO at Troy Web Consulting
Not every problem needs AI. But there are problems you'd never have thought to solve before, and learning to spot them is the hard part.
The customer who was green until they weren't
Let's say you're running a software company that's doing well. Your account team is on top of things and every dashboard is green. Then one of those green accounts tells you they're not renewing.
For most businesses, that email is the first warning they get. Looking back, the signs were there. Support tickets had been piling up, logins were dropping off, and the person who championed you had left the company. It was all spread across five different systems, and nobody had time to connect the dots.
I think that gap between what your data knows and what your team actually sees is where agentic thinking starts.
How we've always solved problems
Most of the work clients bring us is well defined. They want an API, a web app, or a real system to replace the spreadsheet they've outgrown. Those are finite problems with a clear right answer, and we know how to solve them: gather the requirements, design it, build it and test it.
That approach still works for most problems, and thinking agentically doesn't mean putting AI into everything. If a process has one exact right answer and every step is already written down, it's a scheduled job, not an agent. That's cheaper and more predictable, and it's the right call.
What changes in 2026
What has changed is the set of problems worth solving. Some problems never looked like software projects because they needed judgment. Someone had to read across a few sources, weigh what they found and decide what to do. People got to those when they had time, or they didn't get to them at all.
An agentic workflow is a set of AI agents, each with a specific job, that gather information, reason about it and recommend or take an action, while people stay in control of the decisions that matter. That opens up problems we couldn't practically solve before.
In my experience the technology is the easier part. Spotting these problems is harder, because they almost never show up as a feature request. They show up after the fact, as “we should have seen that coming.”
Back to the customer who didn't renew
One way to think about it is to boil a customer down to all the signals they give off in your business. Some are simple, and your CRM may already track them: the last time they signed in to your portal, the last time an account manager reached out.
Now widen the view:
- Product usage (Amplitude, for example): daily active users, feature adoption, activity trends
- Support (Zendesk): ticket volume and the sentiment behind them
- Billing (Stripe): revenue, payment health, the renewal date
- Relationships (Salesforce): stakeholders, champions, changes in who owns the account
- Communication (Slack): response rate and engagement
You probably already have these tools, so collecting the data isn't the hard part. The difference is having something that reasons across all of it, all the time, and tells your team what it means and what to do next. Off-the-shelf customer success platforms cover some of this, but they're usually expensive and slow to roll out, and they're built around their own idea of how your business works.
Seven building blocks of an agentic workflow
For our team's internal training on agentic workflows, we built a working version of this scenario: a Customer Health Score Agent. It's a good way to see the seven concepts behind every agentic workflow. Each one is a design decision we make on purpose, not something AI does on its own.
01 Planning and decomposition
Breaks “is this customer healthy?” into small, clear steps: gather, analyze, score, recommend, route.
Why it matters: a vague goal becomes a repeatable process.
02 Multi-agent collaboration
Separate agents each watch one system (product, support, billing, CRM, Slack) and report back.
Why it matters: swap a tool and you replace one agent, not the whole system.
03 Tool selection
Agents only dig into the data a situation calls for, like checking the CRM when an account manager leaves.
Why it matters: costs and noise stay low across hundreds of accounts.
04 Research and synthesis
Turns the findings into one explanation, not just a score: usage is down, tickets are up, the champion left.
Why it matters: your team gets the story, not another number.
05 Reflection and self-critique
Checks its own work before anyone sees it, including whether something innocent, like a holiday slowdown, explains the dip.
Why it matters: fewer false alarms, so people keep trusting it.
06 Decision trees and routing
Sends each result to the right place: critical accounts to leadership, billing issues to finance, product friction to product.
Why it matters: the right person hears about it at the right time.
07 Iterative refinement
Learns from which flagged accounts actually left, and from account managers' feedback.
Why it matters: it gets more accurate the longer it runs.
Together
None of these works alone. Combined, they produce a customer scorecard that updates as things happen, explains itself and comes with a recommended next step.
That's how you get ahead of the cancellation email instead of reading it. Customers notice when you reach out before they've had to complain, and that's hard for a competitor to copy.
Try the Customer Health Score Agent
How to spot an agentic problem
When a client describes a problem, these are the questions we ask:
- Do you have to check several systems to answer it?
- Does it take judgment, or is there one exact right answer?
- Is it something someone should be watching, but nobody has time to?
- Does the answer need an explanation and a next step, not just a number?
- Would missing it be expensive? Think lost renewals, missed bids or compliance issues.
If you're answering yes to a few of these, it's probably worth a conversation.
People stay in control
Agentic doesn't mean unattended. When our team spent a day building five agentic prototypes at our recent Lab Day, the same rules held for every one: nothing touches production and guardrails come first, a person reviews every output, and you measure the cost of a real run before you build. Agents do the first pass and people make the call. We hold client work to the same standard.
Where to start
I think the next few years are about moving from “build me an app” to “help me see what I'm missing.” If you have a problem that lives across five systems and a few people's heads, that's a good place to start. Let's talk.
