
The use case is the boundary that transforms human intention into a distributed AI architecture.
Contents
- The AI-Native question
- Ivar Jacobson and Ericsson
- AXE, PLEX and Function Blocks
- HLPLEX, processes and FORLOPP
- From Ericsson languages to concurrent systems
- From function blocks to AI building blocks
- One use case, decomposed end to end
- The use case as an AI boundary
- When context becomes a layer above the function
- Conclusion
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.
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.

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.
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.
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
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 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
- Ivar Jacobson β biography and work
- Ivar Jacobson International
- Object Management Group β UML
- Ruby Ractor documentation
- Model Context Protocol
- Google Cloud β Agentic AI security operations workflow
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.