Software Engineering is changing… and fast.
In this video, I introduce a new way to think about systems:
Everything is an Agent.

Instead of building static, rigid applications, we move toward living, adaptive systems built on three core components:

Data → all inputs, context, configuration
Decision → the brain (LLMs)
Direction → actions (return, self-iterate, or tools)

This is what I call Software Engineering 2.0.

In this video, you’ll learn:
The tri-nature architecture (Data → Decision → Direction)
How LLMs act as the decision-making brain
Why systems become iterative and self-validating
How agents call tools, other agents, or themselves
A real POC demo generating + validating JSON
How this leads to dynamic, adaptive user interfaces
Why local LLMs (like PeerLLM / Ollama) change everything

This is just the beginning of the series.

Next videos will walk you through:
0/ Building full agent systems end-to-end
1/ Multi-agent orchestration
2/ Dynamic UI generation
3/ Real-world production architectures

If this resonates with you:
Drop a comment and tell me what you want to see next.

Like & Subscribe for more on Software Engineering 2.0

Link to demo here:
https://github.com/hassanhabib/STX.Agent.Demo.Session2/tree/master

Chapters
0:00 — Everything Is an Agent
0:08 — The Problem with Static Software
0:30 — Software Engineering 2.0 Mindset
1:15 — The Three Components: Data, Decision, Direction
2:30 — What “Data” Really Means
3:45 — The Decision Layer (LLMs as the Brain)
5:10 — Direction: Actions an Agent Can Take
6:08 — How Decisions Turn into Actions
6:58 — Iteration Loop (Return, Self, Tool)
8:00 — Tools, Functions, and Multi-Agent Systems
8:58 — Full Architecture Breakdown (Burn This In Your Memory)
9:50 — Example: Generate a Student JSON
10:38 — Validation Loop (Generate → Validate → Return)
11:30 — Live POC Demo
12:28 — Running a Local Agent (No Token Costs)
13:14 — Improving the Prompt & Output
14:14 — Why Local LLMs Matter
15:07 — The Future: Adaptive Interfaces
16:08 — Multi-Agent Orchestration Explained
17:00 — What’s Next in the Series

We Are .NET

A conceptual overview of 'Software Engineering 2.0' where everything is modeled as an AI agent. The framework proposes three agent types: exposers (interface/input handling), orchestrators (coordination), and integrators (specialized task execution). Each agent has three internal components: data (static inputs), decision (LLM reasoning), and direction (return, self-call, or tool call). A live demo shows a local LLM agent generating and validating a JSON student object across multiple self-iterating steps. The vision includes adaptive UIs that change based on user context and multi-agent teams that dynamically compose capabilities like data retrieval, email, and SMS without pre-built features.