Building Agentic AI Applications with a Problem-First Approach

The AI landscape has evolved dramatically. We have moved beyond simple chatbots and rule-based systems into an era where AI agents can reason, plan, and autonomously execute complex workflows. Yet, despite these technological leaps, many AI initiatives fail, not because of inadequate technology, but because they start with the wrong question.

Instead of asking, “What can AI do?” we should be asking, “What problem are we actually solving?”

This is the essence of the problem-first approach to building agentic AI applications, a methodology I have refined through years of architecting enterprise-scale systems and, more recently, developing intelligent observability platforms.

What Makes AI “Truly Agentic”?

Before diving into the problem-first methodology, let us clarify what we mean by “agentic AI.”

A truly agentic AI system exhibits three core characteristics:

1. Autonomous Decision-Making: The agent does not just respond to prompts; it analyzes context, evaluates options, and makes decisions based on defined goals and constraints.

2. Goal-Oriented Behavior: Rather than executing predefined scripts, agentic systems work backward from desired outcomes, dynamically planning and adapting their approach.

3. Continuous Learning & Adaptation: True agents learn from interactions, refine their strategies, and improve performance over time without explicit reprogramming.

Think of it this way: A chatbot answers questions. An agentic AI solves problems.

The Problem-First Framework

Step 1: Define the Core Problem (Not the Solution)

Most AI projects start with excitement about technology: “Let us use GPT-4!” or “We need a RAG system!” This is solution-first thinking, and it is a recipe for building impressive demos that solve nothing.

Problem-first thinking starts differently:

• What specific pain point exists? (e.g., “Our DevOps team spends 15 hours/week manually correlating logs, metrics, and traces”)
• Who experiences this pain? (e.g., Site Reliability Engineers, Database Administrators)
• What’s the measurable impact? (e.g., “Mean Time to Resolution (MTTR) averages 4 hours for production incidents”)
• What would success look like? (e.g., “Reduce MTTR to under 30 minutes with automated root cause analysis”)

Example from my work:

When building an observability platform, I did not start with “Let us add AI to monitoring.” I started with “Engineers waste hours correlating disparate data sources during incidents. How can we eliminate this cognitive overhead?”

Step 2: Map the Problem Domain

Once you have defined the problem, map its boundaries:

• Data landscape: What information exists? Where does it live? How is it structured?
• Human workflows: How do people currently solve this problem? What expertise do they apply?
• Decision points: Where do humans make judgment calls? What criteria do they use?
• Constraints: What are the non-negotiables? (latency, accuracy, compliance, cost)

This mapping reveals whether AI is even the right solution, and if so, what type of AI architecture makes sense.

Step 3: Design for Agency, Not Automation

Here is where many projects go wrong: they automate existing workflows instead of reimagining them for autonomous agents.

Automation replaces human actions with scripts. Agency replaces human reasoning with intelligent decision-making.

Key design principles:

• Goal-oriented architecture: Define outcomes, not steps
• Context awareness: Agents need rich situational understanding
• Explainability: Decisions must be traceable and auditable
• Human-in-the-loop: Critical decisions should involve human oversight
• Graceful degradation: Agents should know when to escalate

Practical example:

Instead of automating “send alert when CPU > 80%”, an agentic system might:

• Analyse historical patterns to determine if this spike is anomalous
• Correlate with recent deployments, traffic patterns, and related services
• Predict impact trajectory
• Recommend specific remediation actions with confidence scores
• Execute low-risk fixes autonomously while escalating high-risk scenarios

Step 4: Build the Minimum Viable Agent (MVA)

Resist the urge to build a comprehensive AI system on day one. Instead:

• Identify the highest-value decision point in your problem domain
• Build an agent that handles just that decision with high reliability
• Validate with real users in production-like conditions
• Measure impact against your success criteria
• Iterate and expand the agent’s capabilities

This MVA approach delivers value quickly while building organizational confidence in AI systems.

Step 5: Instrument for Continuous Improvement

Agentic systems should improve over time. Design for observability from day one:

• Decision logging: Capture every decision the agent makes and why
• Outcome tracking: Did the agent’s decision lead to the desired result?
• Feedback loops: Enable users to rate agent performance
• A/B testing: Compare agent decisions against human baselines
• Drift detection: Monitor for degradation in decision quality

Real-World Application: An Observability Platform Case Study

Let me illustrate this framework with a concrete example from my recent work.

The Problem

DevOps teams managing complex microservices architectures face “alert fatigue” and struggle to identify root causes during incidents. They are drowning in data but starving for insights.

The Problem-First Approach

1. Problem Definition:

• Engineers receive 100+ alerts per incident
• 80% of alerts are noise or symptoms, not root causes
• Average MTTR: 4+ hours
• Goal: Reduce noise by 90%, cut MTTR to <30 minutes

2. Domain Mapping:

• Data sources: Logs, metrics, traces, deployment events, infrastructure changes
• Human expertise: Pattern recognition, correlation analysis, system knowledge
• Decision points: “Is this alert actionable?” “What is the root cause?” “What should we do?”

3. Agentic Design:

Instead of rule-based alerting, we built an agent that:

• Continuously analyzes system behaviour to establish baselines
• Detects anomalies in context (time of day, deployment cycles, traffic patterns)
• Correlates signals across data sources using causal inference
• Generates hypotheses about root causes, ranked by probability
• Recommends specific remediation actions with risk assessments

4. MVA Implementation:

I started with a single use case: database performance degradation. The agent:

• Monitors query performance metrics
• Correlates with application traces and infrastructure metrics
• Identifies specific slow queries, missing indexes, or resource constraints
• Recommends optimisation actions

5. Continuous Improvement:

Every agent decision is logged with:

• Input context (what data was analyzed)
• Decision rationale (why this conclusion)
• Recommended actions: Outcome (was the issue resolved? How long did it take?)

This feedback loop enables the agent to refine its decision-making models continuously.

Common Pitfalls to Avoid

• Technology-First Thinking: Starting with “Let’s use LangChain/AutoGPT/CrewAI” instead of understanding the problem deeply.
• Over-Engineering: Building a general-purpose AI agent when a focused, domain-specific agent would deliver more value.
• Ignoring Human Expertise: Failing to capture and encode the tacit knowledge of domain experts.
• Lack of Explainability: Creating “black box” agents that users do not trust or understand.
• No Feedback Mechanism: Building static agents that cannot learn from their mistakes.

The Business Case for Problem-First Agentic AI

When you start with the problem, the ROI becomes clear:

• Measurable impact: You define success metrics upfront
• Faster time-to-value: MVA approach delivers incremental wins
• Higher adoption: Solutions that solve real pain points get used
• Sustainable investment: Clear ROI justifies continued development
• Competitive advantage: Problem-solving beats feature-matching

Conclusion: From Hype to Impact

The AI industry is awash in hype. Every vendor promises “AI-powered” everything. But the organizations seeing real value from AI are not chasing trends; they are solving problems.

The problem-first approach to building agentic AI applications is simple:

• Start with a clearly defined problem and success criteria
• Map the problem domain thoroughly
• Design for agency, not just automation
• Build and validate incrementally (MVA)
• Instrument for continuous learning

This methodology transforms AI from an experimental technology into a strategic capability that delivers measurable business value.

As we enter an era where AI agents will handle increasingly complex decisions, the winners will not be those with the most sophisticated models; they will be those who apply AI to the right problems in the right ways.

What problems are you solving with agentic AI? Could you share your experiences in the comments below?