Back to Blog

Core Capabilities of Agentic Applications, from First Principles

InsightsNovember 18, 20266 min read
Kevin Denman, Founder @ AgentGraph

LLMs have not just changed the way we build software, they have fundamentally altered what software is. This can be better thought of as a paradigm shift, with the entire world shifting from "apps" to "agents". In discussing the software that leans into agents as primitives, I find it helpful to call these agentic applications.

I propose three core capabilities that agentic applications must have:

  1. High Agency¹ — agentic apps are capable of completing work-level tasks from start to finish.
  2. Self-Improving² — they are capable of recursive improvement using observability (read) and coding agents (write).
  3. Interoperable³ — they are capable of integrating with internal and external agents to achieve their goals.

Example use case: an agentic application for property managers to onboard new clients

In this example, we will take a property manager who needs to onboard a new homeowner. The goal of the onboarding process is to build a relationship with the new customer and get important details on their needs.

In order to design an agentic application for client onboarding, we will follow a design process that helps tie the workflow to an agentic system design:

  1. Workflow design — map the current state workflow without agents;
  2. Agent design — map agents and tools to parts of the workflow you think are candidates;
  3. System design — draw the agents within an agentic system architecture.

Workflow design

An existing workflow is evidence that a series of tasks are being done to create some valued outcome. Starting with a workflow helps ground the design process to the desired outcomes the agent should be able to achieve. In most cases, only a subset of a workflow will be agent-addressable. This means that the final system design needs to encapsulate the end-to-end workflow, including agents, humans, and any other actors (like existing systems).

Each workflow should be packaged in a sequence diagram⁴. The sequence diagram captures the most important details for any workflow: the actors (vertical lanes), the sub-workflows (horizontal lanes), and the steps (lines connecting two actors within a workflow).

The below example shows a subset of the homeowner onboarding workflow where the property manager establishes the preferences of the homeowner. To establish the homeowner's preferences, the property manager prepares for an onboarding session, conducts the onboarding session, completes follow-ups, and continuously updates these preferences over time.

The current-state workflow: the property manager establishes the homeowner's preferences across four sub-workflows, with no agents involved
The current-state workflow: the property manager establishes the homeowner's preferences across four sub-workflows, with no agents involved

Agent inclusion in the workflow design

Now that we have a basic workflow, we can consider adding an agent to it. In the diagram below, we propose building an agent to own the "establish preferences" step during the larger onboarding workflow. It works directly with the owner solely on this. But how do we make the agent the best in the world at "establishing preferences"?

An agent takes ownership of the "establish preferences" step, working directly with the owner
An agent takes ownership of the "establish preferences" step, working directly with the owner

Agents need tools to be high-agency

When we build agentic applications, they need to be high-agency. Q&A chatbots do not have agency. A high-agency assistant does not just send a homeowner a form. It does research on the customer and their property, talks to the internal team, develops a call plan, and shows up to the onboarding call prepared to run the call.

To do this, the agent needs tools that provide it with context and capabilities the model cannot. Every green line between the tools and the agent below offers additional context and capabilities.

  • Search property records tool searches the web
  • Read customer records tool reads the CRM
  • Write interview plan tool generates a call plan grounded on SOPs

With these tools, the agent is able to conduct the onboarding session live with the homeowner. After the onboarding session, the agent can choose more of its tools to complete follow-ups.

  • Update customer records tool writes to the CRM
  • Draft customer preferences tool generates a customer preferences document grounded on SOPs
  • Schedule meeting tool between the property manager and the homeowner

Next, it can work toward scheduling a high-value 15-minute human-to-human meeting where the property manager establishes the human relationship with the owner, already knowing the detailed facts about the property and the owner's stated preferences.

In the diagram below, we start to see the early shape of a simple agentic application focused on onboarding a new homeowner to a property management company. It's using the right primitives, so it will be able to expand into additional domain-specific use cases quickly.

Tools give the agent the context and capabilities to prepare for, run, and follow up on the onboarding session
Tools give the agent the context and capabilities to prepare for, run, and follow up on the onboarding session

Agentic application architecture for observability (read) and self-improvement loops (write)

Once the agentic application in the diagram above is implemented, how will we know it is actually the best in the world at establishing homeowner preferences? And if it isn't, how do we make it better?

This idea of continuous self-improvement can seem like a problem to solve later, but I believe it is a first-order problem and a core capability for agentic applications that intend to compete and win. There are two primary reasons for this:

  • Inputs and outputs of agentic applications are nondeterministic, requiring observation and evaluation⁵
  • Coding agents commoditize software coding tasks, making continuous improvement loops⁶ economically viable

Without observability systems and coding agents, self-improving agentic applications would not be feasible. With these systems, your agentic application has alpha and the second core capability required to compete and win.

The below diagram adds observability and a coding agent into the agentic product, enabling it to learn from gaps and failures observed and implement updates to improve them.

  • Session traces land on an observability layer where we can see which tools were used, what the agent did, if the user was frustrated or happy, and how much it cost
  • Evaluators in the observability layer analyze the traces to identify failure patterns and feature gaps, and automatically pass them to coding agents
  • Coding agents assess the merits of the gap, and if warranted, implement the improvements directly to the system

Observability (read) and a coding agent (write) close the loop: session traces surface gaps and failure patterns, and the coding agent updates the tools and the agent
Observability (read) and a coding agent (write) close the loop: session traces surface gaps and failure patterns, and the coding agent updates the tools and the agent

Design for interoperability with third-party agents instead of boiling the ocean

While coding agents make it tempting to write every piece of software ourselves, boiling the ocean is still largely a bad idea. Just as with any software application, integration architecture is critical to ensure your agentic application can leverage inter-agent partnerships. There are two core patterns to think through here:

  1. Using other agents as a service to make your agent more powerful
  2. Allowing other agents to use your agent, to help them become more powerful

In the diagram below, we introduce our first third-party agent, a voice agent, that we use to enable our agentic product to have best-in-class voice capabilities without having to build voice-specific infrastructure. Even better, let's say this third-party agent has configurable property management domain plugins. Now, we can do our interviews in voice mode and make our agentic product more powerful.

A third-party voice agent runs the owner interview and hands the transcript and answers back to our agent
A third-party voice agent runs the owner interview and hands the transcript and answers back to our agent

Wrap-up

To summarize, agentic applications are a fundamentally new software category. Using coding agents to write non-agentic software may be valuable for a time, but this ignores the larger paradigm shift underway that will eventually consume it. Agentic applications will continue to flourish as they take on more useful work, optimize their self-improvement capabilities, and find the natural order of build vs. buy in the new agentic web, or "agent graph".

As these agentic applications become the new standard, they will form the backbone of all AI-native services startups⁷, DeployCos, and AI-native SaaS. The winning agentic products will be high agency, self-improving, and lean into agent interoperability.

These core capabilities of agentic products are grounded in the first principles of what's physically possible today with AI architectures: high agency, recursive self-improvement, and agent-to-agent coordination. Combining these capabilities will ultimately deliver the most economic value when applied to viable use cases.

The full agentic application: a high-agency agent with tools, a self-improvement loop, and third-party agents working together
The full agentic application: a high-agency agent with tools, a self-improvement loop, and third-party agents working together

Sources

  1. Task Completion Time Horizons
  2. Evals Are the Product Feedback Loop
  3. Cross-Harness Agent Development
  4. Sequence diagrams: the good thing UML brought to software development
  5. Demystifying evals for AI agents
  6. A Field Guide to Rapidly Improving AI Products
  7. How to Build an AI-Native Services Company

AgentGraph designs agentic systems and places forward-deployed engineers with enterprise teams. If you're figuring out how to design an agentic application that is high agency, self-improving, and interoperable, let's talk.