Imran Siddique

Posted on Jan 2

The End of "Chat": Why AI Interfaces Must Be Polymorphic

#agents #design #ui

Stop forcing your AI to just talk. Let it build.

If you are building AI agents today, you are likely stuck in the Text Trap.

You build a sophisticated agent that can query databases, analyze live telemetry, or debug code. But then you force it to squeeze all that rich intelligence into a single, lossy format: A chat bubble.

User: "How’s the server latency?"
Agent: "The server latency is currently high, peaking at 2000ms..."

This is a UI failure.

If a human engineer saw that latency spike, they wouldn't write a paragraph about it. They would look at a Line Chart. If they found a bug in the code, they wouldn't explain it in a chat window; they would fix it directly in the IDE via Ghost Text.

We need to stop treating AI as a chatbot and start treating it as a Polymorphic Engine.

The Concept: Just-in-Time UI

I recently implemented a system I call Polymorphic Output. The core philosophy is simple: If input can be anything (multimodal), output must be anything.

The Agent shouldn't just generate text; it should generate Intent and Data. The Interface Layer then decides—in real-time—how to render that data based on the user's context.

Context: Chat Window → Output: Text/Cards
Context: IDE → Output: Ghost Text/Diffs
Context: Dashboard → Output: Live Widget
Context: Critical Alert → Output: Toast Notification

The Architecture

The implementation (which you can find in the [linked repo]) separates the "Brain" from the "View."

1. The Modality Detector

Instead of a simple return string, the agent passes its response through an OutputModalityDetector. This module analyzes two things: Data Type and Urgency.

Is it time-series data? → Modality.CHART
Is it tabular data? → Modality.TABLE
Is it a code fix? → Modality.GHOST_TEXT
Is the urgency > 0.9? → Modality.NOTIFICATION

2. The Generative UI Engine

This is where the magic happens. The engine takes the raw data and the modality hint, and generates a UI Component Specification.

This isn't a hard-coded React component. It's a JSON description of a UI that should exist.

{
  "component_type": "DashboardWidget",
  "props": {
    "title": "API Latency",
    "value": "2000ms",
    "trend": "up",
    "alertLevel": "critical"
  },
  "style": {
    "borderLeft": "4px solid #FF0000"
  }
}

Your frontend (React, Flutter, etc.) simply reads this JSON and renders the component.

Real-World Scenarios

Here is how this changes the user experience:

Scenario A: The DevOps Dashboard

Old Way: You ask the bot "Show me errors." It replies with a text list of log lines. You have to read them.
Polymorphic Way: You ask "Show me errors." The agent detects a stream of error logs. It switches modality to DASHBOARD_WIDGET. A live, red-bordered widget appears on your screen, updating in real-time.

Scenario B: The IDE Copilot

Old Way: You ask "Fix this bug." The bot replies in a side window: "You should change line 42 to..."
Polymorphic Way: You ask "Fix this bug." The agent detects it is inside an IDE context. It switches to GHOST_TEXT. The solution appears directly in your editor as a gray suggestion. You hit Tab to accept.

Scenario C: The Data Analyst

Old Way: "Get me the top 10 users." Bot returns a Markdown list.
Polymorphic Way: The agent detects tabular data. It renders an Interactive Table. You can click the headers to sort by created_at or filter by email.

The Startup Opportunity: Generative UI SDKs

There is a massive gap in the market right now for a Generative UI SDK.

Developers are tired of hard-coding every single screen, form, and chart. They want to drop in a library that takes Agent Output and automatically renders the perfect UI.

Imagine an SDK where you write:

# The agent just returns data
response = agent.run("Show me sales trends")

# The SDK decides it needs a Bar Chart and renders it
ui.render(response)

No manual parsing. No building specific chart components. Just data in, UI out.

Conclusion

We are moving away from "Chat" and toward "Computing."

Chat is a great interface for negotiation, but it is a terrible interface for consumption. When we decouple the Agent's intelligence from the text box, we unlock the true potential of AI: an adaptive, polymorphic interface that builds itself to fit the problem at hand.

The future isn't a better chatbot. It's a UI that adapts to you.

You can find the reference implementation for the Polymorphic Output Engine and Generative UI SDK on my GitHub.

DEV Community