"We are witnessing a shift from Chat Interfaces to Agent Interfaces.
While Vision-based agents demonstrate impressive capabilities, they face a fundamental structural limitation: they operate on the visual projection meant for humans, not the semantic truth of the system.
To build reliable, deterministic enterprise agents, we need a new approach.
This whitepaper proposes Intelligence Interface (I²)—an architecture where both the Human UI and the Agent Semantics are projected from a single domain source. It's an RFC (Request for Comments) for the future of AI-native application standards."
Intelligence Interface
A Semantic Architecture for AI-Native Applications
Whitepaper v1.0
Abstract
AI Agents have begun to operate applications. Yet today's UI was designed solely for humans—forcing Agents to infer invisible rules from what they can see. This is fundamentally incomplete.
This whitepaper proposes Intelligence Interface (I²): an architecture that generates both the UI humans see and the semantics AI understands from a single source of truth.
The essence of I² is simple:
UI is a visual projection of the domain. AII is a semantic projection of the domain.
The two projections differ in form but share the same origin. This separation becomes the foundation of application architecture in the AI era.
1. The Nature of the Problem
1.1 UI Was Designed for Humans
For thirty years, UI evolved with only one consumer in mind: humans. Button colors, layout flows, animation timing—every detail was optimized for human cognition and perception.
This design succeeded. Humans can now intuitively operate complex systems through UI.
1.2 A New Consumer Emerges
In 2024, a new UI consumer appeared: the AI Agent.
Agents perceive UI in a fundamentally different way:
- Humans recognize visual patterns
- Agents parse structural data
UI optimized for humans is informationally impoverished for Agents.
1.3 What Is Missing
UI is a partial projection of the domain. What appears on screen is the tip of the iceberg. Beneath the surface lies:
- Why is this button disabled?
- Under what conditions does this field appear?
- What must be entered to proceed?
- Which rules validate this value?
Humans can use UI without this information. They learn patterns through trial and error, guided by intuition.
Agents are different. For Agents, "trial and error" is failure, and "intuition" is hallucination.
1.4 The Decisive Example
A user asks an Agent:
"I need to select a day of the week, but why isn't the day selector showing?"
Vision Agent's limitation:
It knows the day selector isn't on screen. But it cannot know why—that information isn't rendered. The Agent can only guess.
I² Agent's response:
To select a day, you need to choose 'Weekly' instead of 'Monthly'
in the Period option. The day selector is currently hidden because
'Monthly' is selected.
This difference is not about model capability. It is about presence or absence of information.
2. Core Insight
2.1 UI Has a Grammar
Observing hundreds of B2B SaaS applications, we discovered a pattern:
Surfaces differ, but structures are identical.
CRUD, Dashboard, Workflow, Settings, Filters. Styles vary by product, but abstract structures are remarkably similar.
The implication is clear:
If UI Grammar exists, Domain and UI can be separated.
2.2 Two Projections
If UI can be separated from Domain, other forms of projection become possible.
Domain
│
┌──────┴──────┐
▼ ▼
UI AII
(for humans) (for Agents)
- UI Projection: Visual representation of the domain. Humans see and interact with it.
- AII Projection: Semantic representation of the domain. Agents read and understand it.
The two projections are different expressions of the same truth.
2.3 Defining Intelligence Interface
Intelligence Interface (I²) is:
A common layer that simultaneously generates the UI humans see and the semantics AI understands, from a single domain source.
I² does not replace UI. I² creates another projection that exists in parallel with UI.
3. Why Vision Alone Is Insufficient
3.1 "What Is Visible" vs. "What Exists"
Vision Agents understand what is visible on screen.
I² Agents understand what exists in the system.
| Question | Vision | I² |
|---|---|---|
| What is this button? | ✓ | ✓ |
| Why is this button missing? | ✗ | ✓ |
| How do I enable this? | Guesses | States conditions |
| What can I do now? | Infers | Responds immediately |
"The reason for what is invisible" is a question Vision cannot answer in principle.
3.2 Inference vs. Lookup
Vision Agents infer at every interaction.
I² Agents look up predefined rules.
This is not merely a performance difference. The complexity class of the problem differs.
- Inference: Probabilistic, uncertain, unexplainable
- Lookup: Deterministic, certain, traceable
I² reduces an inference problem to a lookup problem.
3.3 Testing and Trust
Vision Agents cannot be tested. A small DOM change can produce entirely different results, with no way to understand why.
I² Agents can be tested. Rules are explicit, enabling unit tests and predictable impact analysis.
Only testable systems can be trusted.
3.4 Explainability
In regulated industries, "why did the AI make this decision" must be explainable.
Vision Agent: "I looked at the screen and determined this button was correct."
I² Agent: "order.status is 'draft' and user.role is 'manager', satisfying the submit conditions."
Decisions that cannot be explained cannot be accountable.
4. Why Now
4.1 The Turning Point
| Period | UI Consumers |
|---|---|
| 1995–2023 | Humans only |
| 2024–2025 | Humans + Agents (experimental) |
| 2026– | Humans + Agents (mainstream) |
Agents operating UI is no longer science fiction. It is happening now.
4.2 Recognition of Current Limits
Vision-based Agents are producing impressive demos. But in production:
- Stability is lacking
- Testing is impossible
- Failure causes are unknown
- Maintenance costs are high
The moment these limitations become widely recognized is approaching.
4.3 Why I² Differs from the Semantic Web
The Semantic Web had a similar vision—"a web machines can understand"—but failed. Why is I² different?
| Semantic Web | I² | |
|---|---|---|
| Scope | The entire web | Form-centric B2B SaaS |
| Generation | Manual tagging | Auto-derived from domain |
| Incentive | Unclear | DX benefits as standalone value |
| Consumer | Unclear | AI Agents as clear consumers |
The Semantic Web failed trying to create "a standard for everything."
I² provides "a practical solution for a specific problem."
5. Philosophical Foundations of I²
5.1 Single Source of Truth
If UI and AII are defined independently, inconsistency between them is inevitable. I² eliminates this problem at its root by making the Domain Layer the single source of truth.
When Domain changes, both UI and AII change automatically. No manual synchronization required.
5.2 Declarative Rules
Business rules should be expressed as data, not code.
Rules expressed as code:
if (period === 'weekly' && items.length > 0) {
showDaySelector()
}
Rules expressed as data:
{
"field": "daySelector",
"visible": ["AND",
["==", "$state.period", "weekly"],
[">", ["LENGTH", "$state.items"], 0]
]
}
Code must be executed to know the result. Data can be read to know the meaning.
What Agents can understand is data.
5.3 Intentional Limits on Expressiveness
I²'s rule system is not Turing-complete. This is by design.
A Turing-complete system:
- Cannot be statically analyzed
- Cannot guarantee termination
- Is difficult to understand
I² provides only the expressiveness necessary for UI decisions. Beyond that, it delegates to the server.
Constraints are not weakness. Constraints create predictability.
5.4 Progressive Adoption
Technology that demands revolutionary change is not adopted. I² permits:
- Adding AII while keeping existing UI
- Building new features with I²
- Gradually transitioning legacy
All-or-nothing becomes nothing.
6. Value Provided by I²
6.1 For Agents
| Value | Description |
|---|---|
| Complete context | Access to hidden rules |
| Deterministic control | Rule-based, not inference-based |
| Explainability | Every action's reason is traceable |
6.2 For Developers
| Value | Description |
|---|---|
| Framework independence | React/Vue/Native from same Domain |
| Declarative development | Rules as schema, not code |
| Testability | Unit tests for business rules |
6.3 For Business
| Value | Description |
|---|---|
| AI automation | Agents safely perform tasks |
| Regulatory compliance | Auditable decisions |
| Future-proofing | Standard architecture for the AI era |
7. Scope of Application
7.1 What I² Solves
- Form-centric transactional applications
- State-driven B2B SaaS
- CRUD business tools
- Workflow enterprise systems
This domain represents an overwhelming share of the commercial software market.
7.2 What I² Does Not Solve
- Real-time canvas collaboration (Figma, Miro)
- CAD / 3D modeling
- Games / Media players
- Highly custom domain-specific UI
This is not selection bias. It is intentional focus.
Technology that tries to solve every problem solves none.
8. Position in the Competitive Landscape
8.1 Relationship with MCP
MCP (Model Context Protocol) defines what an Agent can do.
I² defines why it can do it and what the current state is.
MCP: "A submit_order function exists"
I²: "submit_order is executable under these conditions..."
MCP handles actions. I² handles meaning.
They are not alternatives—they are complements.
8.2 Difference from RPA
RPA depends on screen coordinates and selectors. When UI changes, it breaks.
I² depends on semantics. When UI changes but meaning remains, it works.
RPA says "click here."
I² says "submit the order."
9. Conclusion
9.1 Core Propositions
- UI is a visual projection of the domain
- AII is a semantic projection of the domain
- Generating both projections from a single source is I²
9.2 Historical Necessity
The limitation of Vision Agents stems not from model capability but from structural absence of information. No matter how intelligent, an Agent cannot read information that does not exist.
I² provides that information.
9.3 Our Conviction
In an era where AI operates applications, a semantic layer becomes not optional but essential.
We are convinced that I² will be the name of that layer.
Appendix: Terminology
| Term | Definition |
|---|---|
| I² | Intelligence Interface |
| AII | AI Interpretation Interface — semantic projection for Agents |
| Domain Layer | Business logic layer containing entities, rules, and constraints |
| Projection | A purpose-specific representation derived from Domain |
| Semantic Snapshot | Complete representation of state + rules + available actions at a point in time |
Intelligence Interface Whitepaper v1.0
"UI is what humans see. AII is what Agents understand. Their origin is one."
Top comments (0)