From idea to impact: how we scope and start an agentic AI project

Since the early days of the generative AI wave, we have been working closely with organizations to navigate the real-world complexity of building agentic AI systems. Across manufacturing, mining, and healthcare, one theme keeps coming up: it's not always obvious where agents will drive the most value, or if they should be used at all.

That’s why we reshaped our technical discovery process to focus on clarity before code in the agentic domain. Our approach unfolds across four key phases: Understand, Ideate, Shape, and Plan. This structure helps uncover the right opportunities, clarify what’s at stake, and align expectations with what agentic AI can truly deliver.

Whether the goal is to streamline customer support, automate quoting, or eliminate tedious manual workflows, success starts with asking better questions. What does “impact” really look like in your context? Where are the real friction points? And what would a smart, outcome-driven system actually need to know and do?

Agentic AI has real potential, but only when it’s built with purpose, grounded in data, and scoped with precision. That’s where our discovery process makes the difference.

Start with the outcome, not the hype

At Osedea, many clients come to us excited about AI agents, often with the ambition to automate entire workflows or overhaul complex systems. It’s a natural response to the hype, but turning that ambition into real impact takes focus.

That’s why we always start by grounding the conversation in outcomes. What are you actually trying to improve, response time, accuracy, throughput, cost efficiency? Where are the real pain points, and how do they show up in metrics or missed opportunities?

This is where our Understand phase comes in. We work closely with teams to unpack the true problem, define what success looks like, and evaluate whether agentic AI is even the right solution. It’s not about scaling automation everywhere, it’s about solving the right problem with the right level of autonomy.

By focusing on measurable goals and operational needs, we set the stage for adoption that’s not just innovative, but sustainable.

Ask the right questions from day one

Every successful agentic AI project starts with a deep understanding of three core elements:

• The business challenge or opportunity
  
• The decision-making process the agent will support or replace
  
• The data and system environment the agent will work within
  

During our initial discovery conversations, we focus on surfacing the right information early. Some of the key questions we ask include:

• What process are you looking to automate or enhance?
  Is it rule-based, repetitive, or judgment-heavy? Where is the current friction?
  
• Who performs this task today, and how?
  What decisions do they make, and what inputs do they rely on?
  
• What outcome are you aiming for, and how will we measure success?
  Think in terms of time saved, error reduction, throughput, or customer experience.
  
• What systems, tools, or APIs will the agent need to integrate with?
  Are those environments structured, accessible, and up-to-date?
  
• Who or what will the agent interact with?
  Internal teams, customers, databases, other AI systems?
  
• How autonomous should the agent be?
  Where do you want it to act independently, and when should it defer to a human?
  
  

These conversations help us go from abstract ideas to actionable scope. They also build shared understanding early, so we’re not just building an agent, we’re solving the right problem.

Define the agent’s scope as light, medium, or heavy

Not every problem needs a fully autonomous agent. To avoid overengineering, and ensure early wins, we classify agent scope along two key dimensions: task complexity and integration depth.

Here’s a simple breakdown:

• Light agents handle simple, isolated tasks within a single system
  Example: Summarizing a document or extracting key fields from a form.
  
• Medium agents manage structured, multi-step workflows within a known environment
  Example: Classifying and routing support tickets based on content and priority.
  
• Heavy agents operate across multiple systems, make dynamic decisions, and adapt over time
  Example: Coordinating an end-to-end sales pipeline with contextual memory and feedback loops.
  
  

To clarify scope, we also ask:

• Can the task be broken into clear, sequential steps?
  
• Does it require reasoning, or is it rule-based?
  
• Will it run in real-time or on a schedule?
  
• Is memory or context retention needed?
  
• Are we dealing with regulated or sensitive data?
  
  

Evaluate your data reality

Once the agent’s role is shaped, planning how it will function starts with a clear-eyed look at your data.

One of the most important parts of this stage is context engineering, the process of defining what information the agent needs at any given moment to make accurate, relevant decisions. (We go deeper on this here.)

To design useful context windows, we assess:

• Data structure – Are we working with structured CRM entries, or unstructured formats like PDFs, audio, or video?
  
• Access points – Will the agent retrieve data from APIs, databases, knowledge bases, or uploaded files?
  
• Preparation needs – Does the data need cleaning, labeling, transcription, OCR, or normalization?
  
• Feasibility and cost – How much data is available, and can we realistically extract the right information at scale, within budget, time, and performance constraints?
  
  

For example, we’ve built agents using multi-turn audio calls and narrated screen recordings, both rely on transcription, but need very different context strategies. Calls require speaker diarization to track who’s speaking and extract intent across a conversation. Narrated videos, on the other hand, need alignment between spoken content and on-screen actions to make sense of the workflow.

At this stage, aligning technical planning with your actual data environment is key, it determines how intelligent and capable your agent can realistically be.

Balance autonomy with oversight

Just because an agent can act autonomously doesn’t mean it should.

A key part of designing agent behavior is deciding where to draw the line between independent action and human oversight. Together with our clients, we explore questions like:

• When should the agent ask for confirmation before taking action?
  
• What actions should always trigger human review?
  
• How will the agent learn, adapt, and build trust over time?

These are not purely technical decisions, they’re strategic ones. The answers shape not only how the agent behaves, but how people interact with it, trust it, and adopt it into their workflow.

Designing for the right level of autonomy means aligning capability with confidence, ensuring the agent delivers value without crossing comfort zones.

Build fast, but start small

With a clear goal, scoped responsibilities, and an understanding of the data reality, we shift into planning mode, mapping out how the agent will actually come to life.

This is where we define architecture, select the tech stack, and sketch out interaction flows and system diagrams. But we don’t aim to build everything at once. Instead, we focus on identifying the smallest valuable outcome we can deliver in just 2–4 weeks.

That might look like:

• Automating one step of a larger workflow
  
• Handling a specific subset of user queries
  
• Running the agent in parallel with a human to compare outputs
  
  

The goal is simple: validate quickly, learn fast, and improve continuously. Starting small allows us to reduce risk, uncover edge cases early, and build trust, both in the system and in the process.

Under the hood: what powers the agent

A powerful agent isn’t just about picking the right model, it’s about designing a system that reasons, acts, and improves over time. At Osedea, we tailor each tech stack to the problem, the environment, and the client’s requirements. Here's how we approach it:

• LLMs: We work across the board, using closed models like GPT, Claude, and Gemini, as well as open-source and self-hosted options (including SLMs) when sovereignty, cost, or fine-tuning is a factor.
  
• Cloud & Compliance: We adapt to your cloud provider of choice, AWS, GCP, or Azure, and design for data sovereignty and compliance from day one.
  
• Orchestration: We frequently use frameworks like LangGraph and Semantic Kernel to coordinate workflows, reasoning loops, and tool usage. But when needed, we build custom orchestration logic to fit more complex or domain-specific needs.
  
• Contextual Retrieval (RAG): We integrate tools like Azure AI Search, Pinecone, Elasticsearch, and other vector databases to ground agent responses in relevant, real-world context. Our approach is tech-agnostic, we choose what fits best.
  
• Observability: We prioritize observability with tools like LangFuse and Application Insights, but also aim for open-source, self-hosted monitoring options, ensuring clients can debug, improve, and retain full control over their agent data.
  

Let outcomes lead the build

Ultimately, agentic AI isn’t about replicating human intelligence but about accelerating business outcomes.

From lighter automations that save time to advanced, cross-system agents that boost efficiency and decision-making accuracy, we translate cutting-edge AI into tangible impact.

We help you identify the right opportunities, define the ideal scope, and build tailored solutions that transform your operations and reduce manual effort.

If you’re curious how an agentic AI project could unlock real value for your team and accelerate your workflows, let’s talk about how we can bring your vision to life.