AbilityMatrix · AI Strategy

The State of AI:
From Commands
to Collaborators

How artificial intelligence shifted from answering questions to understanding what you're actually trying to achieve — and what that means for your organisation.

Executive Brief April 2026

The journey so far

AI in Three Chapters

Chapter 1

Where We Started: AI as a Question Machine

Prompt-in, answer-out. Every interaction started from zero — no memory, no context, no continuity.
The skill was in the asking. Getting useful results required becoming a specialist in prompt construction.
One question at a time. If your real problem required ten steps, you had to do nine yourself.

Someone still had to do all the thinking. AI was a very fast search engine with better sentences.

Chapter 2

The First Shift: AI That Can Do Things

Skills, not just sentences. Modern AI can search, read files, update systems, send messages — inside one request.
The shift from assistant to actor. AI moved from "here is information" to "I have done the task."

Real example: Field rep records a voice note. Agent transcribes, extracts commitments, updates CRM, drafts follow-up. Manual time: under two minutes.

Chapter 3

The Second Shift:
AI That Knows Your Situation

Context is the difference between advice that sounds right in general and guidance that fits your specific situation right now.

Without Context

"Here is a standard quarterly review template."

Useful to nobody in particular. Requires heavy customisation before it can be used.

With Context

"Here is a review draft using your team's data, your previous quarter's priorities, and the framing your CFO prefers."

Ready to use.

Context = memory + documents + role. Modern AI systems can hold your company knowledge, previous conversations, and your preferences all at once.
The AI learns your organisation. Feed it your processes, your terminology, your customers - it stops being generic and starts being yours.
From search to understanding. Context is why "AI finally gets it" - because it actually knows what "it" means in your world.

Chapter 4 · The Frontier

How AI Work Has Evolved:
From Prompts to Intent

Each stage represents a shift in who does the thinking - from you specifying every step, to the AI pursuing the outcome you defined.

Chapter 4 · The Frontier

What Intent-Driven AI
Actually Changes

The final shift - AI that doesn't just execute a request, but understands the goal behind it and works toward that, even when the task changes.

The task is no longer the unit of work - the outcome is. You describe what success looks like. The AI figures out the tasks required to get there.
It adapts when reality changes. If a step fails or new information arrives, intent-driven systems adjust their plan rather than stopping and waiting.
This is where AI becomes a genuine collaborator. Not a tool you operate, but a system that works alongside you toward a shared goal.

Intent is not magic. It requires well-structured context, reliable skills to call on, and humans who can define success clearly. The better your first three layers, the more powerful this becomes.

So What

What This Means for
Your Organisation

Four concrete shifts every leadership team needs to plan for now.

1

Execution becomes a commodity

AI handles the doing. Competitive advantage shifts to judgment - knowing what to build, what to ask, and what "good" looks like. Domain expertise becomes more valuable, not less.

2

Review capacity is the new bottleneck

Agents produce at 100x. Organisations review at 3x. The constraint has shifted from output to oversight. The person who can spot what's wrong fast becomes the most valuable person in the room.

3

Your data is now your moat

Companies with clean, structured operational data will use AI far more effectively than those without. Data quality is a strategic asset, not an IT problem.

4

Know your one-way doors

Human hesitation in workflows was a risk brake, not inefficiency. Before removing it, ask: if this goes wrong, can we reverse it? One-way doors need compensating controls before agents touch them.

Concrete Example

From Field Notes to
Business Intelligence

A mid-market distribution company needed better visibility into what their field sales team was actually hearing from customers.

Before

Sales reps wrote up notes after visits - maybe. CRM data was incomplete. Management had no way to spot patterns across 40 reps until the quarterly review.

After

Voice memo → structured data. Reps speak for 90 seconds after each call. AI extracts objections, competitor mentions, and next steps. Patterns visible in 48 hours, not 90 days.

No new software for the reps. The AI layer sits behind the scenes. User experience is unchanged.
Management finally has signal, not noise. Aggregated themes replace anecdote-driven strategy calls.
The AI understood the intent - "give us sales intelligence" - not just the task of transcription.

This pattern applies equally to manufacturing quality audits, consulting engagement reviews, customer success calls, and any domain where insight is currently trapped in unstructured conversation.

Governance

Before You Automate:
One-Way vs. Two-Way Doors

The question is not whether to use AI agents. It is which decisions should remain under human control - and which ones are safe to hand over.

One-Way Door

Cannot be undone

Deleting records or files
Sending communications externally
Financial transactions
Overwriting production data

Requires: human approval gate, audit trail, rollback mechanism before agents can act here.

Two-Way Door

Reversible or low-stakes

Drafting content for review
Summarising and classifying
Internal recommendations
Research and synthesis

Safe to automate fully — the cost of a mistake is low and recovery is straightforward.

Human hesitation in workflows was not inefficiency — it was a risk brake. Before removing it, make sure the door swings both ways.

Action

What to Do Next

The organisations winning with AI are not the ones who studied it longest. They're the ones who started smallest and learned fastest.

1

Pick one high-friction workflow

Not the biggest transformation. The one your team complains about most. That is your pilot.

2

Define success before you start

What does "working" look like in four weeks? Be specific. Vague intent produces vague results - from humans and AI alike.

3

Build internal capability, not dependency

The goal is to develop people who understand how to work with AI, not just vendors who operate it for you. That capability compounds over time.

4

Ship in weeks, not quarters

Modern AI tools make prototyping fast. A working proof-of-concept in 30 days teaches you more than six months of planning.

abilitymatrix.com · Confidential

AbilityMatrix · Builder Brief

Building with Modern AI:
Skills, Context,
and Intent

The technical foundations of agentic AI - for practitioners who need to build things, not just understand them.

Technical · Builder Level April 2026

The journey so far

AI in Three Chapters

Where we were, where we are, and where the next 6-9 months take us.

Layer 1

Prompt Engineering:
Necessary Foundation,
Not the End State

What prompt engineering actually is:

Instruction shaping. Controlling output format, tone, structure, and depth through precise language.
Few-shot examples. Showing the model what "correct" looks like, so it pattern-matches your expected output.
Constraint injection. "Do not change any of the words, just fix typos" - explicit guardrails prevent over-reach.

Why it's not enough alone:

Stateless by default. Each call starts fresh. No memory of the project, the user, or past decisions.
The human is still the loop. Multi-step tasks require manual chaining - you become the orchestration layer.
Prompt brittleness. Small input variations break carefully tuned prompts. Not production-robust.

Prompt engineering moved us from "AI toy" to "AI tool." Skills, context, and intent are what move us from tool to system.

Layer 2

Skills and Tool Use:
How Agents Call Functions

Tool use is the mechanism that transforms a language model into an agent. The model decides when and how to invoke external capabilities.

Tool definitions are JSON schemas. You tell the model the tool's name, description, and parameter structure. The model decides when to invoke it - and with what arguments.
Skills = reusable tool bundles. A "sales notes" skill might wrap transcription + CRM write + email draft as a single invocable unit.
Verification loops close the quality gap. The best tool patterns include a verifier: the model checks its own output against a ground truth before returning a result.

Tool use ≠ workflow execution. An agent that can call tools is not the same as an agent that can follow a multi-step process reliably. Skills orchestrate; tools are the primitives they invoke.

"Do not mistake the ability to call tools with the ability to follow a workflow. Those are not the same things." — The gap between the two is where most production failures happen.

Layer 3

Context Architecture:
System Prompts, Memory,
and Retrieval

System Prompt (Static Context)

The foundational instruction layer. Defines persona, constraints, output format, domain knowledge, and organisational rules. Loaded once, applies everywhere.

Example: "You are an expert in our field sales process. When extracting CRM data, always use these field names..."

Memory (Dynamic Context)

Persisted state across sessions. Without it, every conversation starts blank. Critical for autonomous agents that need to track multi-day project progress, user preferences, or operational state.

Pattern: key-value store or vector DB, injected at conversation start.

RAG - Retrieval (Situational Context)

Retrieval-Augmented Generation. The model queries a knowledge base at runtime and pulls only the relevant chunks into context.

Solves the context window limit - you can have millions of documents, model only sees the right few.

Compaction (Context Management)

Long conversations fill context windows. Compaction summarises older turns, discarding low-signal content while preserving key facts.

Strategic forgetting improves performance and reduces cost. Not all history is useful history.

Context architecture is where most AI implementations fail. The model is rarely the bottleneck - the information plumbing is. Invest here first.

Layer 4

Intent Parsing:
Structuring Inputs So AI
Knows the Goal, Not Just the Task

The gap between what a user says and what they actually want is where most AI systems fail. Intent parsing closes that gap by design.

Task-framed input

// Fragile - breaks when reality changes
user: "Summarise the meeting notes
  from last Tuesday and email
  them to the team."

// AI executes exactly this.
// What if no notes exist?
// What if the team changed?
// It stops and asks.
        

Intent-framed input

// Robust - goal-oriented
intent: "Keep the team aligned on
  meeting outcomes"
context: "weekly ops call, 6 people,
  decisions logged in Notion"
constraints: "brief, action-item focused,
  send by 5pm same day"

// AI plans the path.
// Adapts if notes are missing.
// Fetches team list itself.
        

Decompose inputs into: intent + context + constraints. This three-part structure is the practical foundation of reliable agentic systems.
The model then plans its own task sequence. It decides how to achieve the intent given the context and constraints, rather than executing a single fixed instruction.

Architecture

Agent Patterns:
Single vs Multi-Agent

Single Agent

Simpler to build, debug, and monitor
Good for well-defined sequential workflows
Context window is the limiting factor at scale

Multi-Agent (Orchestrator + Specialists)

Parallel execution - specialist agents run concurrently
Each sub-agent has its own focused system prompt and tools
Orchestrator manages intent and assembles outputs

Start with a single agent. Add sub-agents when a task can be genuinely parallelised or when specialist context isolation provides meaningful quality improvement. Complexity has a cost.

Craft

Anatomy of a
Good Tool Definition

The quality of your tool definitions directly determines the quality of agent behaviour. This is where most of the real engineering work lives.

// A well-structured tool definition
{
  "name": "extract_sales_note",
  "description": "Extract structured data from a field
    sales voice note transcript. Use this
    when a rep has submitted a post-call memo
    and needs CRM fields populated.",     // WHY + WHEN to use it
  "input_schema": {
    "transcript": "string",   // raw text
    "rep_id": "string",     // for CRM routing
    "call_date": "ISO8601"  // always explicit types
  },
  "output_schema": {
    "objections": "string[]",
    "next_steps": "string[]",
    "competitor_mentions": "string[]",
    "sentiment": "positive|neutral|negative"
  }
}
    

Description tells the model WHY and WHEN - not just what the tool does but when to reach for it versus another option.
Explicit schemas prevent hallucinated fields. If the model knows the output must be a string array, it won't invent sub-objects.
Keep tools narrow. One tool doing one thing well beats a Swiss Army tool the model has to guess at.

Pattern in Practice

Voice Memo →
Structured Output Pipeline

A real architecture pattern: converting unstructured field audio into operational intelligence, without changing any rep behaviour.

System Prompt Layer

Domain: field sales context, CRM field names, sentiment definitions, company terminology. Loaded once, applies to every note.

Tool Layer

transcribe_audio, extract_sales_note, write_to_crm, draft_follow_up. Each with explicit schemas.

Intent Layer

"Capture sales intelligence from every field interaction without adding friction to rep workflow." The agent plans the path.

Human Gate

Rep reviews the draft email and CRM entry. One tap to approve. Nothing writes to production without human confirmation.

Watch Out

Common Failure Modes
and How to Prevent Them

!

Context starvation

The model produces generic outputs because it has no domain knowledge. Fix: invest heavily in system prompt design and retrieval before tuning the model itself.

!

Intent-task mismatch

You specify the task, AI does exactly that task, misses the actual goal. Fix: frame every agent input with intent + context + constraints, not just "do X."

!

Tool overload

Giving the agent 30 tools degrades decision quality - the model struggles to choose correctly. Fix: keep active tool sets under 10. Use specialist sub-agents for domain-specific tool sets.

!

No verification loop

Agent produces output, system accepts it without checking. Fix: every consequential output needs a task verifier - a trusted method of confirming the agent's output actually achieves its goal.

!

Production vs. demo confusion

The agent makes no technical error — it is simply wrong about which world it is operating in. Fix: explicit environment flags in every system prompt. If your agent can act in the world without a permissions layer, you have a demo, not a product.

!

Conversation state ≠ workflow state

Most frameworks conflate them. When an agent crashes mid-tool, it cannot know whether the tool completed. Fix: separate your task state store from your conversation history. They are different problems requiring different solutions.

"Please do not mistake the ability to call tools with the ability to follow a workflow. Those are not the same things."

Playbook

Where to Start:
A Builder's Checklist

Week 1-2 · Foundation

1

Map the workflow

Document inputs, outputs, decisions, edge cases. This is your spec. AI cannot improve a process you haven't understood.

2

Write the system prompt

Domain knowledge, constraints, output format. Test it with edge cases before writing a line of tool code.

3

Define 3-5 core tools

Start narrow. Each with a tight schema and a clear description of WHEN to invoke it. Build the verifier alongside the tool.

Week 3-4 · Ship

4

Add persistent context

Memory store + RAG if needed. This is the difference between a demo and a product people actually use every day.

5

Human review gate

For any consequential action, build the approval step before you build the action. Trust is earned incrementally.

6

Observe and iterate

Log every tool call and output. The failure modes you'll fix in week 5 will only appear in production. Expect them. Plan for them.

The organisations building production AI systems fastest are the ones who plan intent, ship narrow, and iterate fast - not the ones who architect the perfect system before writing a line of code. abilitymatrix.com

The State of AI:From Commandsto Collaborators

AI in Three Chapters

Where We Started: AI as a Question Machine

The First Shift: AI That Can Do Things

The Second Shift:AI That Knows Your Situation

How AI Work Has Evolved:From Prompts to Intent

What Intent-Driven AIActually Changes

What This Means forYour Organisation

From Field Notes toBusiness Intelligence

Before You Automate:One-Way vs. Two-Way Doors

What to Do Next

Building with Modern AI:Skills, Context,and Intent

AI in Three Chapters

Prompt Engineering:Necessary Foundation,Not the End State

Skills and Tool Use:How Agents Call Functions

Context Architecture:System Prompts, Memory,and Retrieval

Intent Parsing:Structuring Inputs So AIKnows the Goal, Not Just the Task

Agent Patterns:Single vs Multi-Agent

Anatomy of aGood Tool Definition

Voice Memo →Structured Output Pipeline

Common Failure Modesand How to Prevent Them

Where to Start:A Builder's Checklist

The State of AI:
From Commands
to Collaborators

The Second Shift:
AI That Knows Your Situation

How AI Work Has Evolved:
From Prompts to Intent

What Intent-Driven AI
Actually Changes

What This Means for
Your Organisation

From Field Notes to
Business Intelligence

Before You Automate:
One-Way vs. Two-Way Doors

Building with Modern AI:
Skills, Context,
and Intent

Prompt Engineering:
Necessary Foundation,
Not the End State

Skills and Tool Use:
How Agents Call Functions

Context Architecture:
System Prompts, Memory,
and Retrieval

Intent Parsing:
Structuring Inputs So AI
Knows the Goal, Not Just the Task

Agent Patterns:
Single vs Multi-Agent

Anatomy of a
Good Tool Definition

Voice Memo →
Structured Output Pipeline

Common Failure Modes
and How to Prevent Them

Where to Start:
A Builder's Checklist