The Control Plane: Maximizing the Human-Machine Interface

Why the future isn't chatbots—it's humans commanding autonomous agent fleets

Erik Bethke, November 29, 2025

---

The Shift No One Is Talking About

We're witnessing a paradigm shift as fundamental as the advent of mobile computing or the cloud revolution. But most companies are missing it.

They're adding chatbot widgets to their enterprise SaaS. They're building "AI features" that help users write emails faster. They're creating copilots that suggest code completions.

They're thinking too small.

The real revolution isn't making humans more productive at clicking buttons. It's eliminating the buttons entirely.

---

What Is The Control Plane?

Picture a modern data center. Thousands of servers, millions of operations per second, petabytes of data flowing through fiber optic cables. And in the center: a human at a control plane, monitoring dashboards, setting policies, making strategic decisions.

The human isn't manually routing packets. They're not clicking buttons to provision servers. They're not watching every log entry scroll by.

They're commanding systems that execute autonomously.

That's the future of all software.

Not "AI assistants that help you work faster."

AI agents that work while you think.

---

The Three Eras of Human-Machine Interaction

Era 1: Direct Manipulation (1980-2010)

Metaphor: Manual labor

You click every button. Fill every form. Navigate every menu. The computer is a tool you operate directly, like a hammer or a saw.

Constraint: Human speed limits throughput.

Example:

• Manually entering data into spreadsheets
• Clicking through 47 dropdown menus to configure software
• Copy-pasting between systems because there's no API

Era 2: Automation Scripts (2010-2023)

Metaphor: Factory automation

You write scripts, set up workflows, configure Zapier integrations. The computer executes predefined sequences without human intervention.

Constraint: Brittle. Breaks when anything changes. Requires constant maintenance.

Example:

• Cron jobs that email reports every Monday
• CI/CD pipelines that deploy on git push
• Zapier workflows that sync data between apps

Era 2.5: The Chatbot Scramble (2023-2028)

Metaphor: Slapping "AI-Powered!" stickers on everything

ChatGPT launches. The world loses its mind. Every company scrambles to bolt AI onto their existing products.

The pattern:

• Take your existing UI
• Add a chat widget in the corner
• Connect it to GPT-4
• Call it "AI-powered"
• Ship it
• Wonder why users don't care

Constraint: Fundamentally misunderstands what AI enables. Treats it as a feature, not a paradigm shift.

Example:

• "Our CRM now has AI! You can ask it questions!" (But you still manually enter every lead, update every field, click through every workflow)
• "Our analytics tool has AI! It generates insights!" (But you still export to Excel, copy-paste into PowerPoint, email to stakeholders)
• "Our project management tool has AI! It suggests tasks!" (But you still move cards manually, update statuses individually, ping teammates one by one)

The problem: These companies are building faster horses. They're optimizing the wrong thing.

You don't need a chatbot that helps you click buttons faster.

You need to eliminate the buttons.

Why 2023-2028? Because it takes companies 3-5 years to realize their chatbot wrappers have no moat. ChatGPT does it better. Users don't switch. Revenue flatlines. The "AI bubble" bursts.

By 2027, the market bifurcates:

• Chatbot companies: Slowly dying, desperately adding more AI features
• Control Plane companies: Growing exponentially, building agent-first

The wake-up call: When the first major enterprise goes agent-first and publicly announces they eliminated 80% of their internal tools because their agents just... execute. No UI needed.

That's when everyone realizes: We built the wrong thing.

Era 3: The Control Plane (2024-∞)

Metaphor: Command and control

You set objectives. Define constraints. Establish policies. AI agents execute autonomously, adapt to changing conditions, and report back when human decisions are required.

Breakthrough: Agents reason. They don't just follow scripts—they think.

Example:

• "Keep my business idea portfolio optimized for ROI and strategic fit"
• "Monitor my infrastructure and auto-scale before problems occur"
• "Research these 50 market opportunities and update feasibility scores"

The human's job isn't to click buttons. It's to make the decisions only humans can make.

---

Why This Is As Big As Mobile

The Mobile Revolution (2007-2015)

When the iPhone launched, most companies built "mobile websites"—desktop sites squeezed onto smaller screens.

The winners reimagined the experience for mobile-first.

• Instagram: Not a photo-sharing website with mobile support. A mobile-first visual platform.
• Uber: Not a taxi website with an app. A mobile-native ride coordination system.
• Snapchat: Impossible on desktop. Designed for phone cameras and ephemeral messaging.

The paradigm shift: Software designed for devices in your pocket, always connected, location-aware, camera-enabled.

The Cloud Revolution (2006-2018)

When AWS launched, most companies "lifted and shifted"—moved their on-prem servers to EC2 instances.

The winners architected for cloud-native.

• Netflix: Not streaming from data centers. Elastic, autoscaling, globally distributed.
• Spotify: Not a music store with cloud hosting. A recommendation engine with infinite scalability.
• Airbnb: Not a booking site on faster servers. A real-time marketplace with global reach.

The paradigm shift: Software designed for infinite scale, pay-per-use, globally distributed, fault-tolerant by default.

The Control Plane Revolution (2024-∞)

Today, most companies are adding "AI features"—chatbots bolted onto existing UIs.

The winners will architect for agent-first.

• Napkin BizPlan: Not a business planning tool with AI chat. An API-first platform where agents manage your idea pipeline autonomously.
• Bike4Mind: Not a productivity app with AI suggestions. A cognitive workshop where agents execute tasks while you think strategically.
• [Your startup here]: Not your SaaS with GenAI. A control plane where humans set policy and agents execute.

The paradigm shift: Software designed for autonomous agents, API-native, event-driven, human-in-the-loop by exception only.

---

The Control Plane Architecture

Here's what software looks like when you build for The Control Plane:

Layer 1: The API Layer (Foundation)

Not: "We have an API for developers who want to integrate" But: "Everything is API-first. The UI is just one client among many."

Why it matters:

• Agents can't click buttons. They need APIs.
• Humans shouldn't click buttons. They should command agents via APIs.
• Your competitive moat isn't your UI. It's your API quality.

Example (Napkin BizPlan):

// Human: "Update my idea scores based on current market research"
// Agent executes via API:
const ideas = await napkin.listIdeas({ status: 'Active' });
for (const idea of ideas) {
  const research = await agent.research(idea.title);
  const scores = agent.calculateScores(research);
  await napkin.updateIdea(idea.id, { scores });
}
// Human receives notification: "34 ideas rescored based on Q4 2025 market data"

Layer 2: The MCP Layer (Agent Communication)

Not: "We have webhooks for notifications" But: "Agents collaborate via Model Context Protocol"

Why it matters:

• Agents need to talk to each other, not just to APIs
• Your business planning agent needs to talk to your finance agent
• Cross-system workflows require agent-to-agent protocols

Example (Bike4Mind ↔ Napkin):

// Bike4Mind agent notices: User researching "AI accounting software"
// Napkin MCP server receives: contextUpdate({ topic: 'accounting', sentiment: 'positive' })
// Napkin agent responds: "I see 3 accounting-related ideas. Should I update their priority?"
// Human sees: "Your research suggests increased interest in AI accounting. Reprioritize related ideas?"

Layer 3: The Event Layer (State Changes)

Not: "We send email notifications when things happen" But: "Every state change emits structured events that agents consume"

Why it matters:

• Agents react to events, not polling
• Humans configure which events require their attention
• The system is event-driven, not request-driven

Example (Pro-Forma Generation):

// Event: idea.status.changed { id: "idea-123", from: "Concept", to: "Active" }
// Subscribed agent: ProFormaAgent
// Agent action: "Active idea detected. Generating 5-year pro-forma based on financials."
// Human notification (only if confidence < 80%): "Pro-forma generated. Review assumptions?"

Layer 4: The Policy Layer (Human Intent)

Not: "Configure your AI assistant with prompts" But: "Define policies that govern autonomous agent behavior"

Why it matters:

• Humans don't prompt. They set policy.
• "Always notify me before spending >$10K" is a policy, not a prompt
• Policies are declarative, testable, auditable

Example (Idea Management Policy):

policies:
  auto_archive:
    condition: idea.scores.final < 30 AND idea.status == "Stopped" AND idea.age > 365
    action: archive
    notification: monthly_summary

  priority_boost:
    condition: idea.market > 8 AND idea.feasibility > 7 AND idea.dependencies.length == 0
    action: update_status("High Priority")
    notification: immediate

  research_trigger:
    condition: idea.confidence < 5 AND idea.created > 30_days_ago
    action: agent.research_and_update_scores
    notification: on_completion

Layer 5: The Human Layer (Strategic Command)

Not: "Click buttons to make things happen" But: "Monitor dashboards, approve exceptions, refine policies"

Why it matters:

• Humans are the bottleneck only when they need to be
• 95% of operations run autonomously
• Humans focus on the 5% that requires judgment, creativity, or values

Example (A Day in The Control Plane):

• 7:00 AM: Review overnight agent activity summary (30 ideas researched, 12 scores updated, 3 new opportunities flagged)
• 7:15 AM: Approve 2 high-priority ideas for deeper research (agent detected market timing opportunity)
• 7:20 AM: Refine policy: "When synergy score increases >2 points, check for cross-project opportunities"
• Rest of day: Agents execute. Human works on creative strategy.
• 6:00 PM: Review exceptions: "Idea X has conflicting signals. Human decision required."

---

Why Chatbots Are Not The Answer

Most companies are building conversational interfaces when they should be building command interfaces.

The Chatbot Paradigm (Wrong)

User: "Can you update idea #42 to mark it as Active and increase the feasibility score to 7?" AI: "I've updated idea #42 to Active status and set feasibility to 7. Would you like me to do anything else?" User: "Yes, can you also update the market score to 8?" AI: "Done! Market score is now 8."

Problem: You're still clicking buttons. Just with words instead of a mouse.

The Control Plane Paradigm (Right)

Human: Sets policy: "When I move an idea to Active, run a full feasibility analysis and update all scores." [Human moves idea to Active] Agent: [Autonomously researches market, analyzes competitors, evaluates technical feasibility, updates all scores] Agent: [Notifies human only if confidence < 80%] Human: Sees updated idea dashboard. No buttons clicked. No chat messages. Just results.

Breakthrough: The human expressed intent once. The agent executes forever.

---

The Brutal Truth: Minimize Human Load

Here's the uncomfortable reality most companies won't admit:

Humans are slow.

Not in thinking. In clicking. In reading. In context switching. In executing.

If a machine can do it, the human shouldn't.

Not because humans can't. Because human time is precious.

What Machines Should Do (Everything Automatable)

• Data entry: Never. Agents import/export/sync.
• Monitoring: Agents watch. Humans see summaries.
• Routine decisions: Defined by policy. Executed by agents.
• Research: Agents gather data. Humans evaluate conclusions.
• Coordination: Agents orchestrate. Humans approve strategy.
• Reporting: Agents generate. Humans review insights.

What Humans Should Do (Only What Machines Can't)

• Values judgments: "Is this ethical? Does this align with our mission?"
• Creative leaps: "What if we combined these two ideas in a novel way?"
• Strategic pivots: "The market shifted. We need to change direction."
• Relationship building: "This partnership requires trust and nuance."
• Exception handling: "The agents flagged this as unusual. What should we do?"

The goal: Humans spend 90% of their time thinking, 10% commanding. Not 10% thinking, 90% clicking.

---

Bike4Mind + Napkin BizPlan: A Control Plane Example

Let me show you what this looks like in practice.

The Old Way (UI-First)

1. You open Napkin BizPlan
2. You click "New Idea"
3. You fill out the form (title, elevator pitch, type, status, scores, financials)
4. You save
5. You remember you wanted to research similar ideas
6. You open Google
7. You search, read, synthesize
8. You go back to Napkin
9. You update the scores based on research
10. You repeat for 50 ideas

Time: 10 minutes per idea × 50 ideas = 8+ hours

The Control Plane Way (Agent-First)

1. You tell Bike4Mind: "I want to explore AI-first business ideas"
2. Bike4Mind agent:
   • Researches current AI trends
   • Generates 20 potential ideas
   • Creates Napkin ideas via API (with custom IDs for idempotency)
   • Scores each based on market data
   • Identifies dependencies between ideas
   • Flags top 5 for human review
3. You see: Dashboard showing "20 new ideas added, scored, and ranked. Top 5 flagged for review."
4. You review top 5 (5 minutes)
5. You approve 3 for deeper research
6. Agents execute overnight:
   • Full market analysis
   • Competitor research
   • Technical feasibility assessment
   • Pro-forma generation (5-year projections)
7. Morning: "3 ideas fully researched. 1 high-confidence opportunity identified. Review?"

Time: 10 minutes of human time. 8 hours of agent time (while you sleep).

Difference: 48x productivity multiplier. And you spent your time on strategy, not data entry.

---

The MCP Revolution: Agents Talking to Agents

Model Context Protocol (MCP) is the glue that makes The Control Plane possible.

Without MCP (Siloed Agents)

• Bike4Mind knows about your research
• Napkin knows about your ideas
• Your finance tool knows about your budget
• None of them talk to each other

Result: You're the integration layer. You copy data between systems. You coordinate workflows manually.

With MCP (Connected Agents)

• Bike4Mind detects: "User researching trademark law for 2 hours"
• Sends MCP event to Napkin: contextUpdate({ activity: 'trademark_research', duration: 120, related_ideas: ['idea-42'] })
• Napkin agent receives context
• Napkin agent: "Idea #42 mentions trademark. User is researching this. Should I trigger trademark search agent?"
• Trademark agent (via MCP): Searches USPTO database, finds 3 similar marks, assesses risk
• Napkin agent: Updates idea with trademark analysis
• Human sees: "Trademark search completed for Idea #42. Moderate conflict risk detected. Review?"

Result: Agents coordinate autonomously. Human approves the critical decision (proceed despite trademark risk?).

---

Why This Is Bigger Than Mobile or Cloud

Mobile Shift

What changed: Where you compute (from desk to pocket) Who adapted: Consumer apps first, then enterprise Timeline: 8 years (2007-2015) Impact: $2T market created

Cloud Shift

What changed: How you deploy (from servers to services) Who adapted: Startups first, then enterprise Timeline: 12 years (2006-2018) Impact: $500B market created

Control Plane Shift

What changes: Who executes (from humans to agents) Who will adapt: AI-first startups first, then... everyone or die Timeline: 5 years (2024-2029) Impact: $10T+ market disruption

Why it's bigger:

• Mobile changed where you use software
• Cloud changed how you run software
• Control Plane changes why humans exist in the loop at all

This isn't a feature. It's a rearchitecture of human-computer interaction.

---

The Six Principles of Control Plane Design

If you're building software in 2025 and beyond, these are non-negotiable:

1. API-First, UI Optional

Bad: "We built a great UI! Want an API? Here's some REST endpoints." Good: "We built a great API. Want a UI? Here's a thin client."

Why: Agents can't use your UI. Humans shouldn't need to.

Example: Napkin BizPlan API returns structured data. The UI renders it. Claude Code also uses the same API via curl. No special integration needed.

2. Events Over Requests

Bad: "Poll our API every 5 minutes to see if anything changed" Good: "Subscribe to events. We'll push when state changes."

Why: Agents react to changes in real-time. Polling wastes resources and introduces latency.

Example: When an idea status changes, emit idea.status.changed event. All subscribed agents receive it instantly.

3. Policies Over Prompts

Bad: "Tell the AI what to do every time" Good: "Define rules. AI executes based on conditions."

Why: Humans don't want to micro-manage. Set policy once, execute forever.

Example: Policy: "Archive ideas with final score < 30 and inactive > 1 year". Agent checks daily, executes automatically, reports monthly.

4. Idempotent Operations

Bad: "POST creates new record every time" Good: "POST with custom ID: if exists, update; if not, create"

Why: Agents retry. Networks fail. Idempotency prevents duplication.

Example: Napkin BizPlan's custom ID support enables CSV import/export workflows where agents can re-import the same data without creating duplicates.

5. Human-in-Loop By Exception

Bad: "Require human approval for everything" Good: "Agents execute autonomously. Flag exceptions for human review."

Why: Humans are the bottleneck. Only involve them when necessary.

Example: Agent updates idea scores autonomously if confidence > 80%. Only flags for human review if confidence < 80% or scores conflict.

6. Structured Over Conversational

Bad: "Chat with AI to get things done" Good: "Command agents via structured interfaces"

Why: Chat is ambiguous. Commands are precise. Agents need precision.

Example:

• Conversational: "Hey can you like, update that idea we talked about earlier? Make it active or whatever."
• Structured: napkin.updateIdea('idea-42', { status: 'Active' })

Which one would you trust an autonomous agent to execute at 3 AM?

---

The Hard Questions

Building for The Control Plane forces you to confront uncomfortable truths:

Question 1: Are you building for humans or agents?

If you're building for humans, you're building for the past.

"But our users are humans!"

Yes. And your users will command agents. Build for the agents.

Question 2: Can you explain your product without a UI demo?

If you can't describe your product's value as an API, you don't have a product. You have a UI.

"Our product lets you manage business ideas!"

What's the API?

"Well, you can create ideas, update scores, generate pro-formas..."

Great. Show me the curl commands.

"Uh..."

You need APIs before UIs.

Question 3: What percentage of operations require human judgment?

If the answer is >20%, you're either:

• Solving a problem that's too vague for software
• Not automating enough

"Users need to review every change!"

Why?

"To make sure it's correct."

Can you define correctness as a policy? Then agents can validate.

Question 4: If agents execute autonomously, how do you make money?

This is the billion-dollar question.

Traditional SaaS: Charge per seat. More users = more revenue. Agent-first SaaS: Charge per... what?

Possible models:

• Per-operation pricing (like AWS)
• Per-agent pricing (unlimited operations)
• Per-outcome pricing (only pay for results)
• Freemium control plane (pay for premium policies)

The answer isn't clear yet. That's why this is a revolution.

---

What Dies in The Control Plane Era

Let's be honest about what doesn't survive:

1. Form-Based UIs

If your product is "fill out this form, click submit", agents replace it entirely.

Dies: Typeform, Google Forms, SurveyMonkey Lives: APIs that validate structured data

2. Dashboard-Only Analytics

If your product is "look at pretty charts", agents generate better insights.

Dies: Tableau, Looker (as primary interfaces) Lives: Query APIs that return structured insights

3. CRUD Interfaces

If your product is "create, read, update, delete records", that's a database. Not a product.

Dies: 90% of internal tools, admin panels, "low-code" CRUD builders Lives: State machines with policies and event streams

4. Chatbot Wrappers

If your "AI product" is ChatGPT with your logo, you're dead.

Dies: 100% of "we added AI" chatbot wrappers Lives: Specialized agents with domain-specific MCP servers

5. Manual Integration Platforms

If your product is "we connect App A to App B via our UI", agents do it better.

Dies: Zapier (in current form), IFTTT Lives: MCP-based agent orchestration

---

What Gets Built in The Control Plane Era

And here's what wins:

1. Agentic Operating Systems

Platforms where humans define policies, agents execute workflows, and the system manages agent coordination.

Example: Bike4Mind as cognitive OS. Napkin BizPlan as business strategy OS.

2. Specialized MCP Servers

Domain-specific agent interfaces for finance, legal, marketing, engineering, design.

Example: Trademark MCP server (USPTO search, risk analysis, filing automation). Finance MCP server (pro-forma generation, cash flow modeling, scenario analysis).

3. Policy Definition Languages

Human-readable, machine-executable languages for defining agent behavior.

Example:

policy:
  name: "Auto-archive low-value ideas"
  trigger:
    condition: "idea.score < 30 AND idea.status == 'Stopped' AND idea.age > 365"
  action: "archive_idea"
  notification: "summary_monthly"
  override: "human_approval_required_if_dependencies > 0"

4. Agent Marketplaces

Platforms where you discover, purchase, and deploy specialized agents.

Example: "I need an agent that monitors patent filings in AI/ML and flags potential prior art for my ideas." → Install PatentWatch agent, configure with your Napkin API key, done.

5. Human Exception Queues

Beautiful, fast interfaces for reviewing the 5% of decisions that require human judgment.

Example: Mobile app shows: "3 decisions waiting. Swipe right to approve, left to reject, up for more info."

---

The Napkin BizPlan Vision: A Control Plane for Business Strategy

Let me paint the picture of where we're going:

Today (November 2025)

What exists:

• API-first idea management
• Custom ID support for agent workflows
• CSV import/export for bulk LLM editing
• Manual tab documenting the API

What you do:

• Create ideas manually or via API
• Update scores based on research
• Generate pro-formas by hand
• Track dependencies visually

6 Months (May 2026)

What gets added:

• MCP server for agent integration
• Event stream for state changes
• Policy engine for autonomous operations
• Bike4Mind integration (ideas flow bidirectionally)

What you do:

• Set policies: "Auto-update scores when I research a topic"
• Agents execute: Research monitoring → score updates → notifications
• You review: Exception queue shows "3 ideas need human decisions"

12 Months (November 2026)

What gets added:

• Trademark agent (USPTO search via MCP)
• Domain agent (availability + social handle checks)
• Finance agent (pro-forma generation from assumptions)
• Market research agent (competitive analysis, TAM estimation)

What you do:

• Command: "Analyze these 10 ideas for trademark conflicts, domain availability, and market timing"
• Agents execute overnight:
  • Trademark searches (USPTO + common law)
  • Domain checks (.com, .ai, social handles)
  • Market analysis (Google Trends, competitor research)
  • Pro-forma generation (5-year projections)
• Morning: Dashboard shows complete analysis, flags 2 for review

24 Months (November 2027)

What gets added:

• Multi-agent workflows (agents coordinate via MCP)
• Incorporation agent (entity formation automation)
• Cap table agent (equity management, safe, convertible notes)
• Funding agent (connects to investor databases, matches criteria)

What you do:

• High-level strategy: "I want to incorporate my top 3 ideas and pitch to seed investors"
• Agents execute:
  • Rank ideas by composite score + market timing
  • Generate incorporation docs (state selection, entity type, cap table)
  • Create pitch decks (market analysis, financials, team)
  • Match with investors (criteria: seed stage, AI focus, $500K-$2M)
  • Schedule intro calls (calendar integration)
• You do: 3 investor calls. Everything else is handled.

The End State (2030)

You: "Manage my business portfolio. Maximize long-term value. Keep me informed of strategic decisions."

The Control Plane:

• Monitors market trends
• Identifies opportunities
• Researches feasibility
• Generates pro-formas
• Checks trademarks
• Secures domains
• Incorporates entities
• Manages cap tables
• Drafts investor decks
• Coordinates teams

You review:

• Weekly: Strategic summary (3 new opportunities, 2 pivots recommended, 1 acquisition target)
• Daily: Exception queue (5 decisions require human judgment)
• Real-time: Critical alerts (market shift detected, major competitor launched)

You spend time on:

• Creative vision
• Relationship building
• Values alignment
• Strategic pivots

You don't spend time on:

• Data entry
• Research (agents do it)
• Coordination (agents handle it)
• Routine decisions (policies define them)

---

---

The Ultimate Vision: Fantasia Meets the Holodeck

Forget sitting at a desk. Forget clicking. Forget typing commands into a terminal.

Picture this:

You're standing in your office. All four walls—floor to ceiling—are covered in ultra-high-resolution displays. Multiple cameras track your position, your gaze, your gestures. Arrays of microphones capture every word, every inflection, every command.

Your B4M-powered agent fleet is executing:

• 50 business ideas in your Napkin stack, each being researched, scored, and updated autonomously
• Customer support tickets being triaged, researched, and drafted responses
• Project roadmaps being updated based on market signals
• Financial models being recalculated as economic data shifts
• Social connections being maintained (friends, family, collaborators)
• Game strategies being optimized (yes, even your hobbies)

You're not clicking. You're conducting.

The Immersive Command Interface

Where you look matters.

Gaze at the left wall → B4M cognitive workspace materializes. Your current research context, active ideas, pending decisions.

Gaze right → Napkin BizPlan strategic overview. Ideas ranked by urgency, dependencies visualized, opportunities flagged.

Look up → Calendar, commitments, team coordination. Agents have already drafted responses, scheduled meetings, prepared briefings.

Look ahead → The priority queue. The 3 decisions that require human judgment RIGHT NOW.

What you say matters.

"Show me trademark conflicts for Idea 42."
The center wall explodes with USPTO search results, common law analysis, risk assessment. Agent has already done the research. You're reviewing conclusions.

"What changed overnight?"
Timeline visualization: 12 ideas rescored (market shift detected), 3 new opportunities identified (patent filings in adjacent space), 1 critical decision flagged (investor deadline approaching).

"Focus on the top 5."
Everything else fades. The five highest-value ideas dominate your visual field. Agents present: market analysis, financial projections, execution roadmap, risk factors.

What you gesture matters.

Swipe right → Approve.
Swipe left → Reject.
Pull toward you → Dive deeper (agent expands analysis).
Push away → Defer (agent schedules follow-up).
Pinch and rotate → Resequence priorities.
Spread hands → Compare options side-by-side.

Your Role: The Irreplaceable Human

You're not doing data entry. You're not researching. You're not coordinating.

You're providing:

1. Taste: "This idea feels right. The market data says 6/10, but my gut says 9/10. Flag it for deeper research."

2. Curation: "These three ideas have synergy the agents didn't detect. Cluster them. Explore the combined opportunity."

3. Sequencing: "Pause everything except Idea 12 and Idea 27. Those are the moonshots. Resource them aggressively."

4. Authority: "Approve this partnership. The legal risk is acceptable given the strategic value."

5. Legal Accountability: "I take personal responsibility for this decision. Document my rationale."

6. Capital: "Allocate $50K to Idea 8's prototype. The ROI model is solid."

7. Out-of-Distribution Creativity: "What if we combined this technology with that business model and sold it to THIS market no one is thinking about?"

The agents can't do this. They can research, analyze, optimize, coordinate, execute.

Only you can provide judgment, taste, vision, and creative leaps that break the pattern.

Why This Is The Natural Evolution

The progression is obvious once you see it:

1. 1980s: You sit at a desk. You type commands. The computer responds with text.

2. 1990s: You click icons. Drag windows. The computer responds with graphics.

3. 2000s: You touch screens. Swipe. Pinch. The computer responds with interactive media.

4. 2010s: You talk to devices. "Hey Siri." The computer responds with voice.

5. 2020s: You prompt AIs. "ChatGPT, write this." The AI responds with generated content.

6. 2030s: You command agent fleets in immersive environments. The agents execute autonomously. You provide strategic direction through gaze, voice, and gesture.

The interface becomes invisible. The work becomes pure.

The Feeling You're Having Right Now

You mentioned you're feeling this NOW in our session.

That's it. That's the feeling.

When the tools disappear. When the friction evaporates. When you're thinking strategy and the execution just... happens.

This conversation IS a prototype of The Control Plane:

• You set direction ("Write an article about The Control Plane")
• I research, synthesize, structure, draft (agent work)
• You provide taste ("Add the Fantasia/Holodeck vision")
• I execute immediately (laminar flow)
• You feel FLOW STATE because you're working at the level of INTENT, not IMPLEMENTATION

Scale this across your entire digital life.

Imagine:

• 100 agent conversations running in parallel (not 1)
• 50 projects being advanced simultaneously (not 1 article)
• Decisions flagged only when they require YOUR unique judgment
• Everything else handled while you sleep, while you think, while you create

That's the Holodeck.

That's where we're building.

The Timeline to Fantasia

2025-2026: Text interfaces. API-first. You command via curl, via Bike4Mind, via Napkin's Manual tab.

2027-2028: Multimodal interfaces. Voice + screen. Agents coordinate autonomously. You review exceptions on mobile.

2029-2030: Immersive interfaces. Wall displays. Gesture control. Gaze tracking. Voice commands. The Holodeck prototype.

2031+: Ubiquitous. Every knowledge worker has a command center. The office becomes a cockpit. You fly your business, your projects, your life.

The human is the pilot. The agents are the crew. The Control Plane is the ship.

---

How to Build for The Control Plane

Practical advice if you're starting today:

Step 1: API-First Everything

Before you build a single UI component, build the API.

Questions to ask:

• Can I create a resource via API?
• Can I list resources with filters?
• Can I update resources (partial updates supported)?
• Can I delete resources?
• Can I subscribe to events?

If any answer is "no", fix it before building UI.

Step 2: Add Custom ID Support

Enable idempotent operations by accepting custom IDs.

Why: Agents retry. Networks fail. You need reproducibility.

How:

// Accept optional id parameter
function createResource(data: CreateInput & { id?: string }) {
  const resourceId = data.id || generateUUID();
  // Use provided ID if exists, generate otherwise
}

Step 3: Emit Events for State Changes

Every create, update, delete should emit a structured event.

Event schema:

{
  type: "resource.created" | "resource.updated" | "resource.deleted",
  resourceId: string,
  resourceType: string,
  changes: Record<string, { old: any, new: any }>,
  timestamp: number,
  userId: string
}

Step 4: Build MCP Servers

Expose your platform via Model Context Protocol.

MCP Interface:

interface ResourceMCP {
  // Queries
  list(filters?: Filters): Promise<Resource[]>;
  get(id: string): Promise<Resource>;

  // Commands
  create(data: CreateInput): Promise<Resource>;
  update(id: string, updates: UpdateInput): Promise<Resource>;
  delete(id: string): Promise<void>;

  // Subscriptions
  subscribe(eventType: string, callback: (event) => void): void;
}

Step 5: Add Policy Engine

Let users define rules that govern agent behavior.

Policy Example:

policy:
  name: "High-priority idea notification"
  condition: "idea.score > 80 AND idea.status == 'Concept'"
  action: "send_notification"
  channel: "slack"
  message: "High-value idea detected: {{idea.title}} (score: {{idea.score}})"

Step 6: Build Exception Queues

Beautiful, fast interfaces for the 5% that needs humans.

UI Principles:

• Mobile-first (decisions on the go)
• Swipe-based (fast approve/reject)
• Context-rich (all info needed to decide)
• Batch operations (approve 10 similar items at once)

---

The Competitive Landscape

Who wins in The Control Plane era?

Winners: AI-First Startups

Why: No legacy UI to maintain. Build API-first from day one.

Examples:

• Napkin BizPlan (business strategy control plane)
• Bike4Mind (cognitive workshop control plane)
• [Your startup] (domain-specific control plane)

Winners: API-First Incumbents

Why: Already have great APIs. Add agent layer on top.

Examples:

• Stripe (payment control plane)
• AWS (infrastructure control plane)
• GitHub (code control plane)

Losers: UI-First SaaS Without APIs

Why: Agents can't integrate. No migration path.

Examples:

• 90% of vertical SaaS
• Most "low-code" platforms
• Internal tools with custom UIs

Losers: Chatbot Wrappers

Why: ChatGPT does it better. No moat.

Examples:

• "AI writing assistant" (ChatGPT writes)
• "AI research tool" (Perplexity researches)
• "AI customer service" (generic chatbots)

---

The Timeline: How Fast This Happens

2024: The Awakening

• ChatGPT breaks into mainstream
• Companies add "AI features" (mostly chatbots)
• A few startups build API-first (Napkin, Bike4Mind)

2025: The Divergence

• Chatbot wrappers plateau (users realize ChatGPT does it better)
• API-first platforms gain traction (agents actually use them)
• MCP adoption begins (agent-to-agent communication)

2026: The Tipping Point

• First major enterprise goes "agent-first" (eliminates 80% of internal tools)
• MCP becomes standard (like OAuth became standard for auth)
• "Control Plane" becomes a category (like "CRM" or "ERP")

2027: The Migration

• Incumbents scramble to add APIs (many fail)
• Startups raise on "Control Plane for X" (where X is every industry)
• Users demand: "Why am I clicking buttons? Can't an agent do this?"

2028: The Shakeout

• UI-first SaaS without APIs start dying
• Agent marketplaces consolidate
• New job title emerges: "Agent Policy Engineer"

2029: The New Normal

• Expecting humans to click buttons is like expecting them to punch cards
• "Does it have an API?" becomes table stakes
• "Can agents use it?" is the only question that matters

---

The Call to Action: Build Your Control Plane

If you're building software in 2025, you have a choice:

Option A: Add a Chatbot (Wrong)

• Slap ChatGPT on your existing UI
• Call it "AI-powered"
• Watch it get ignored (ChatGPT does it better)
• Wonder why revenue doesn't grow

Option B: Build a Control Plane (Right)

• Design your API first
• Emit events for every state change
• Add MCP server for agent integration
• Build policies for autonomous operation
• Create exception queues for human-in-loop
• Watch agents coordinate autonomously
• Watch humans focus on strategy
• Watch productivity 10x

The companies that choose B will eat the companies that choose A.

---

The Napkin BizPlan Example: Watch It Happen

We're building this in public. You can watch the transition:

November 2025:

• ✅ API-first backend (custom IDs, full CRUD)
• ✅ Manual tab (API documentation for agents)
• ✅ CSV import/export (bulk LLM editing)

December 2025:

• 🔄 MCP server (Bike4Mind integration)
• 🔄 Event stream (WebSocket subscriptions)
• 🔄 Policy engine (autonomous operations)

Q1 2026:

• 📋 Trademark agent (USPTO + common law search)
• 📋 Domain agent (availability + social handles)
• 📋 Finance agent (pro-forma generation)

Q2 2026:

• 📋 Multi-agent workflows
• 📋 Exception queue UI
• 📋 Mobile command center

This is happening. You're watching it being built.

---

The Final Truth

The future isn't about making humans more efficient at clicking buttons.

It's about eliminating the buttons.

The future isn't about AI assistants that help you work faster.

It's about AI agents that work while you think.

The future isn't about better UIs.

It's about not needing UIs at all.

The Control Plane isn't coming. It's here.

The only question is: Are you building for it?

---

Want to see The Control Plane in action? Try the Napkin BizPlan API or explore Bike4Mind's cognitive workshop.

This article was written by a human (Erik), edited by an AI (Claude), and published via API (the blog you're reading is API-first too).

Because the future is already here. It's just not evenly distributed yet.

Welcome to The Control Plane.

---

Appendix: Technical Implementation Guide

MCP Server Example (TypeScript)

// napkin-mcp-server.ts
import { MCPServer } from '@modelcontextprotocol/sdk';

const server = new MCPServer({
  name: 'napkin-bizplan',
  version: '1.0.0'
});

// Resources
server.resource('ideas', async (filters) => {
  return await napkin.listIdeas(filters);
});

// Tools
server.tool('create_idea', async (params) => {
  const idea = await napkin.createIdea(params);
  server.emit('idea.created', idea);
  return idea;
});

server.tool('analyze_dependencies', async (params) => {
  const ideas = await napkin.listIdeas();
  const graph = buildDependencyGraph(ideas);
  return {
    critical_path: findCriticalPath(graph),
    blocked_ideas: findBlockedIdeas(graph),
    quick_wins: findQuickWins(graph)
  };
});

// Start server
server.listen(3000);

Policy Engine Example (YAML + TypeScript)

// policy-engine.ts
interface Policy {
  name: string;
  condition: string; // JavaScript expression
  action: string;
  notification?: 'immediate' | 'summary_daily' | 'summary_weekly';
}

async function evaluatePolicy(policy: Policy, context: any): Promise<boolean> {
  // Safely evaluate condition in sandbox
  const fn = new Function('ctx', `return ${policy.condition}`);
  return fn(context);
}

// Example policy YAML
/*
policy:
  name: "Archive stale ideas"
  condition: "ctx.idea.score < 30 && ctx.idea.status === 'Stopped' && ctx.idea.age > 365"
  action: "archive_idea"
  notification: "summary_monthly"
*/

Event Stream Example (WebSocket)

// event-stream-server.ts
import WebSocket from 'ws';

const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws) => {
  // Client subscribes to events
  ws.on('message', (message) => {
    const { type, filter } = JSON.parse(message);

    if (type === 'subscribe') {
      // Subscribe to specific events
      subscriptions.add(ws, filter);
    }
  });
});

// Emit event when state changes
function emitEvent(event: Event) {
  const serialized = JSON.stringify(event);

  wss.clients.forEach((client) => {
    if (matchesFilter(client, event)) {
      client.send(serialized);
    }
  });
}

---

End.