Edit this page


From Ericsson Use Cases to AI-Native Systems

The use case is the boundary that transforms human intention into a distributed AI architecture.

Contents

The AI-Native question

The AI industry often presents intention-driven systems as something entirely new. But an AI-Native system does not simply receive an intention and autonomously invent the entire solution.

It must understand what the intention means, determine what the system is responsible for, identify the participating actors, decompose the business process and select the appropriate capabilities.

The real starting point is not the agent.

It is the use case.

Actor
  β†’ Intent
    β†’ Use Case
      β†’ Business Process
        β†’ Responsibilities
          β†’ AI Building Blocks
            β†’ Outcome

The use case turns an intention into a bounded responsibility. It tells the system who participates, what must happen, what is allowed, what is outside the boundary, what counts as success and what evidence must be produced.

A requirement states what should happen. A use case defines the bounded process through which it can happen.

Ivar Jacobson and Ericsson

Before use cases became widely associated with UML, Objectory and the Rational Unified Process, Ivar Jacobson was working at Ericsson on large, real-time telecom systems such as AKE and AXE, including PLEX.

Jacobson is widely credited with introducing use cases in 1986 as a way to specify functional software requirements. The idea emerged from a practical problem: how to understand systems whose behaviour was distributed across software units, processes, signals and hardware.

The historical connection matters because the use case was not created as a decorative documentation technique. It was a way to reason about responsibility:

Who interacts with the system?
What does the actor need to accomplish?
What functions are required?
Where does each responsibility live?
How do the units cooperate?

AXE, PLEX and Function Blocks

The AXE system gives this history a concrete form. PLEX-C was used to produce software for the central processor of the AXE control system. Functional blocks could also involve hardware and regional software running in regional processors.

This meant that a system function was not necessarily located in one place:

Central Software
  + Regional Software
    + Hardware
      + Functional Blocks
        + Signals

The conceptual decomposition was:

Actor
  β†’ Use Case
    β†’ System Function
      β†’ Function Block
        β†’ Software Unit
          β†’ Process
            β†’ Signal / Event

A Function Block was not simply a source-code file. It represented a function within a larger application system, potentially combining software, local data, signal interfaces, associated hardware and regional software.

Mermaid diagram

Legend: the Function Block is the unit of composition within the application system; it brings together software, data, interfaces and physical or regional resources.

The use case gave the function its reason for existing. The Function Block gave the function an architectural home.

HLPLEX, processes and FORLOPP

HLPLEX made active execution and concurrency more explicit. Modules could contain processes; processes could execute concurrently, have multiple instances and communicate through event paths.

Function Block
  └── Module
       β”œβ”€β”€ Process A
       β”œβ”€β”€ Process B
       └── Process C
Process A
  β†’ Event
    β†’ Process B

The unit was no longer only a container of functionality. It became an active participant in a larger process.

The AXE documentation also describes FORLOPP as a sequence of events. When multiple Function Blocks participated in the same call, records could be linked into a chain with a Forlopp Identity, or FID.

Call
  β†’ Record in Block A
    β†’ Record in Block B
      β†’ Record in Block C
        β†’ Record in Block D

FID = identity of the distributed call

The FID allowed the system to identify and release a specific call in the event of a software failure. This is not identical to a modern trace ID or agent run ID, but the architectural question is related:

How does one preserve the identity of an operation while it crosses multiple units?

From Ericsson languages to concurrent systems

The historical arc can be read as:

PLEX
  β†’ HLPLEX
    β†’ Erlang
      β†’ Elixir

This should not be understood as a direct succession of compilers or language versions. PLEX and HLPLEX were Ericsson languages and execution environments for telecom systems; Erlang emerged later from the same Ericsson context and addressed related problems at a broader level.

The important continuity is architectural:

PLEX / HLPLEX
  β†’ Function Blocks
  β†’ Processes
  β†’ Events and Signals
  β†’ Distributed Execution

Erlang / Elixir
  β†’ Processes
  β†’ Message Passing
  β†’ Isolation
  β†’ Supervision
  β†’ Fault Tolerance

Erlang and Elixir therefore belong to a longer Ericsson tradition of decomposing complex systems into interacting, concurrent and recoverable units. The lineage is not only syntactic. It is a lineage of architectural concerns: decomposition, communication, concurrency, isolation, supervision and composition.

AI-Native systems extend this lineage with another layer:

Distributed Execution
  β†’ Intent
    β†’ Context
      β†’ Adaptive Feedback

The function is still distributed, but its participation can now be directed by an intention and the context in which that intention is being pursued.

From function blocks to AI building blocks

The history of software paradigms is also a history of changing answers to one question:

What is the right unit for realizing a responsibility?

OOP
  β†’ Object = data + behaviour

PLEX
  β†’ Function Block = function + software + hardware

HLPLEX
  β†’ Process = state + behaviour + events

Erlang / Elixir
  β†’ Process = isolation + messages + supervision

Ruby / Ractors
  β†’ Unit = isolation + parallel execution

AI-Native
  β†’ Agent = state + behaviour + intent + feedback

The paradigms are not identical and do not form a simple chain of direct inheritance. They respond to related pressures: decomposition, encapsulation, communication, concurrency, recovery, composition and responsibility.

From Use Case to AI Building Blocks

An AI-Native system is not composed only of agents. It is composed of different building blocks, each with a distinct role:

Responsibility Building block
Specialized knowledge Skill / RAG
Concrete execution Tool
External integration MCP
Known sequence Workflow
Adaptive judgment Agent
Persistent context Memory
Lifecycle control Hook
Sensitive authorization Human actor

The use case determines which of these are necessary.

One use case, decomposed end to end

Begin with a bounded objective:

🧭 INTENT

Investigate a production incident and produce a verified report.

Before decomposing this intention into AI building blocks, we can express it as a classic use case: an authorized engineer interacts with an incident-investigation system to obtain a verified report and, when necessary, approve a risky change.

Mermaid diagram

Legend: the use case diagram identifies the actor, the system boundary, the goal and the controlled extension requiring authorization.

This is not yet an architecture. We first turn it into a bounded use case:

An authorized engineer requests an investigation. The system gathers relevant documentation and telemetry, forms and tests hypotheses, records evidence, produces a report and requests human approval before any risky production change.

The use case diagram defines the goal and the system boundary. The sequence below shows how that goal is realized over time, with context directing which capabilities participate at each stage.

Mermaid diagram

Legend: the sequence shows context as an active participant in execution, not merely as information loaded before the agent starts.

The distributed business process becomes visible:

Incident Investigation
  β”œβ”€β”€ receive the request
  β”œβ”€β”€ identify the affected service
  β”œβ”€β”€ retrieve relevant documentation
  β”œβ”€β”€ inspect logs and metrics
  β”œβ”€β”€ form hypotheses
  β”œβ”€β”€ run safe verification steps
  β”œβ”€β”€ evaluate evidence
  β”œβ”€β”€ produce a report
  └── request approval for risky action

Each responsibility can now be assigned to an appropriate participant:

Receive and classify request       β†’ Coordinator Agent
Retrieve runbooks and documentation β†’ RAG
Apply incident procedure           β†’ Skill
Query logs and metrics             β†’ Tool
Connect to observability systems   β†’ MCP
Compare hypotheses                 β†’ Investigation Agent
Execute standard checks            β†’ Workflow
Preserve findings and context      β†’ Memory
Block unsafe operations            β†’ Hook / Policy
Approve production changes         β†’ Human Actor
Mermaid diagram

Legend: the diagram separates context, execution and governance; the use case routes the intention through bounded capabilities toward evidence and human-verified completion.

The diagram does not show one super-agent performing everything. It shows a distributed process in which each building block has a bounded responsibility.

The use case as an AI boundary

The use case is the boundary that transforms intention into AI architecture:

Use Case
  β†’ defines purpose
    β†’ assigns responsibility
      β†’ restricts authority
        β†’ selects building blocks
          β†’ defines completion

For every agent, skill, tool or workflow, we should be able to ask:

Which use case requires this?
Which responsibility does it realize?
What authority does it have?
What does it communicate?
What evidence does it produce?
When must it stop?

This prevents common category errors:

Agent β‰  Skill
Skill β‰  Tool
Tool β‰  MCP
MCP β‰  RAG
RAG β‰  Memory
Hook β‰  Workflow

Not every responsibility needs to become an agent. Not every capability needs autonomy. Not every document needs to become memory. Not every integration needs to become an MCP server.

The use case must decide.

Intention should not be confused with a prompt. A prompt is one possible interface to an AI model; an intention is the human or business purpose that gives the system direction.

Intention β‰  Prompt
Intention β†’ Use Case β†’ Context β†’ AI Execution

The use case also defines what must not happen: actions outside the scope, capabilities without authority, data that cannot be used, decisions that require human approval and conditions under which execution must stop. This negative space is part of the architecture.

When context becomes a layer above the function

In a traditional distributed system, the main architectural question was often where a function should execute:

Use Case
  β†’ System Function
    β†’ Function Block
      β†’ Process
        β†’ Signal

In an AI-Native system, the functions still exist, but a contextual layer helps decide which ones should participate in the current situation:

Intent
  β†’ Use Case
    β†’ Context
      β†’ Responsibilities
        β†’ Functions and AI Building Blocks
          β†’ Action and Evidence

Consider the same production incident under two different contexts:

Context Directed execution
A service is degraded, but no data loss is detected Retrieve runbooks, inspect metrics and perform safe diagnostics
The same service shows possible data corruption Retrieve recovery procedures, increase evidence requirements and require human approval before changes

The underlying functions may be similar, but the context changes their order, authority and level of caution. In the first situation, a diagnostic workflow may be enough. In the second, the system may need additional RAG sources, a specialized skill, an investigation agent, stronger hooks and a human checkpoint.

This is the additional layer introduced by AI-Native systems:

Function = what can be done
Context  = what matters now
Use Case = why it is being done and where it must stop

The use case therefore does not replace the distributed function. It gives direction to the function through context, throughout execution.

In this sense, intention becomes an architectural input:

Intent
  β†’ Use Case
    β†’ Context
      β†’ System Boundary
        β†’ Responsibilities
          β†’ AI Building Blocks

The use case is the bridge between human intention and system design. It turns intention into a bounded context in which AI can reason, act, produce evidence and stop.

Conclusion

The Use Case Loop

The history of software composition can be read as a history of changing units:

Object
  β†’ Function Block
    β†’ Process
      β†’ Supervised Application
        β†’ Ractor
          β†’ Agent

Each unit addressed a different aspect of complexity:

Object           β†’ encapsulation
Function Block   β†’ functional composition
Process          β†’ active execution
Message          β†’ communication
Supervision      β†’ recovery
Ractor           β†’ isolation and parallelism
Agent            β†’ intention and adaptive action

But the unit alone is never enough. A system also needs purpose, responsibility, authority, context, constraints, evidence and completion.

The use case provides that definition. It is where a human intention becomes a system responsibility, where a business process becomes an architectural boundary and where the system decides what belongs inside the solution and what must remain outside it.

πŸ“„ TAKEAWAY

AI-Native systems do not begin with agents. They begin with intentions that become use cases, use cases that become responsibilities, and responsibilities that become carefully chosen building blocks.

The use case is where intention becomes architecture. It does not remove the need for system modeling; it gives system modeling a more direct starting point.

References

The AXE, PLEX and HLPLEX historical details in this article were checked against Ericsson training manuals supplied as research material. The article paraphrases those materials and does not reproduce their proprietary diagrams or code.