/internal/docs/ROADMAP_2026.md

Go Micro Roadmap 2026: The AI-Native Era

Last Updated: March 2026

Executive Summary

The emergence of AI agents represents a paradigm shift in how services are consumed. Where APIs served apps, MCP serves agents. Go Micro is uniquely positioned to become the standard microservices framework for the agent era.

This roadmap outlines Go Micro's evolution from an API-first framework to an AI-native platform while maintaining backward compatibility and ensuring long-term sustainability.

---

The Paradigm Shift

Before: Apps → API Gateway → Services

┌──────────┐     HTTP/REST      ┌─────────────┐     RPC      ┌──────────┐
│  Mobile  │ ───────────────→   │   Gateway   │ ─────────→   │ Services │
│   App    │                    │  (Express)  │              │          │
└──────────┘                    └─────────────┘              └──────────┘

Characteristics:

• Apps need HTTP/REST/GraphQL
• Manual API design (OpenAPI specs)
• Developers write integration code
• Static endpoint documentation

Now: Agents → MCP → Services

┌──────────┐      MCP/SSE       ┌─────────────┐     RPC      ┌──────────┐
│  Claude  │ ───────────────→   │     MCP     │ ─────────→   │ Services │
│   GPT    │                    │   Gateway   │              │          │
└──────────┘                    └─────────────┘              └──────────┘

Characteristics:

• Agents discover tools automatically
• No manual API design needed
• Agents write their own integration code
• Dynamic tool discovery

Why This Matters

API Gateways solve integration for developers. MCP solves integration for AI.

Go Micro's MCP integration means:

1. Zero integration work - Services become AI-accessible instantly
2. No API wrappers - Agents call services directly
3. Dynamic discovery - New services = new tools automatically
4. Natural language interface - No documentation needed

---

Strategic Vision

Mission Statement

Make every microservice AI-native by default.

2026-2027 Goals

1. MCP becomes the default - micro run enables MCP automatically
2. Best-in-class agent integration - The easiest way to expose services to AI
3. Sustainable business model - Open core with premium offerings
4. Production deployment at scale - 1000+ services running MCP gateways
5. Ecosystem leadership - The go-to framework when AI needs microservices

---

Roadmap

Q1 2026: MCP Foundation ✅ COMPLETE

Status: COMPLETE as of February 2026

Delivered

• MCP library (gateway/mcp)
• CLI integration (micro run --mcp-address)
• Service discovery and tool generation
• HTTP/SSE transport
• Documentation and examples
• Blog post and launch

Impact

• Services are now AI-accessible with 3 lines of code
• Both library and CLI users can use MCP
• Foundation for agent-first development

---

Q2 2026: Agent Developer Experience

Status: COMPLETE (100%) - All core features and documentation delivered

Theme: Make it trivial for any AI to call your services

MCP Enhancements

Stdio Transport for Claude Code ✅ COMPLETE (delivered early)

• Implement stdio JSON-RPC protocol
• Auto-detection: stdio vs HTTP based on environment
• micro mcp command for Claude Code integration
• Example: Add go-micro services to Claude Code

Why: Claude Code and other local AI tools use stdio MCP servers. This enables:

# In Claude Code config
{
  "mcpServers": {
    "my-services": {
      "command": "micro",
      "args": ["mcp"]
    }
  }
}

Business value: Direct integration with Anthropic's flagship developer tool.

Tool Descriptions from Comments ✅ COMPLETE (delivered early)

• Parse Go comments to generate tool descriptions
• Support JSDoc-style tags: @param, @return, @example
• Schema generation from struct tags
• Auto-generate examples from test cases

Before:

Tools:
- users.Users.Get - Call Get on users service

After:

Tools:
- users.Users.Get
  Description: Retrieve user profile by ID. Returns full profile including email,
               name, created date, and preferences.
  Parameters:
    - id (string, required): User ID in UUID format
  Returns: User object with profile fields
  Example: {"id": "123e4567-e89b-12d3-a456-426614174000"}

Why: Better descriptions = better agent performance. Agents need context to call services correctly.

Multi-Protocol Support

• WebSocket transport for streaming (JSON-RPC 2.0, bidirectional)
• gRPC reflection for MCP (bidirectional streaming)
• Server-Sent Events with auth (HTTP/SSE implemented)
• HTTP/3 support

Why: Different agents prefer different protocols. Support them all.

Agent SDKs

Create official SDKs for popular agent frameworks:

LangChain Integration ✅ COMPLETE

• langchain-go-micro Python package
• Auto-generate LangChain tools from registry
• Example: Multi-agent workflow with go-micro services
• Published to contrib/langchain-go-micro/

AI Package ✅ COMPLETE

• ai.Model interface with Generate and Stream
• Anthropic Claude provider (ai/anthropic)
• OpenAI GPT provider (ai/openai)
• Tool execution with auto-calling support
• Provider auto-detection from base URL

Why: The ai package powers the agent playground and enables services to call AI models directly.

LlamaIndex Integration ✅ COMPLETE

• go-micro-llamaindex package
• Service discovery as data sources
• Example: RAG with microservices

AutoGPT/AgentGPT Support

• Plugin format adapter
• Auto-install via plugin marketplace
• Example: Autonomous agents orchestrating services

Business value: Every agent framework can use go-micro services out of the box.

Developer Experience

micro mcp Command Suite ✅ COMPLETE

Implemented:

# Start MCP server
micro mcp serve                    # Stdio (for Claude Code) ✅
micro mcp serve --address :3000    # HTTP/SSE (for web agents) ✅

# Development
micro mcp list                     # List available tools ✅
micro mcp list --json              # JSON output ✅
micro mcp test users.Users.Get     # Test a tool ✅
micro mcp docs                     # Generate MCP documentation ✅
micro mcp docs --format json       # JSON output ✅
micro mcp export langchain         # Export to LangChain format ✅
micro mcp export openapi           # Export as OpenAPI ✅
micro mcp export json              # Export as JSON ✅

Interactive Agent Playground

• Web UI for testing services with AI
• Built into micro run dashboard
• Chat with your services
• See agent tool calls in real-time
• Share playground URLs for demos

Example:

http://localhost:8080/playground

> You: "Show me user 123's last 5 orders"

Agent: Let me check that...
→ Calling users.Users.Get with {"id": "123"}
→ Calling orders.Orders.List with {"user_id": "123", "limit": 5}

Here are the 5 most recent orders for Alice Smith:
1. Order #45678 - $125.00 - Shipped (Jan 15)
2. Order #45123 - $89.99 - Delivered (Jan 10)
...

Business value: Instant demos. Show investors/customers AI calling your services.

Documentation

• "Building AI-Native Services" guide ✅ COMPLETE
• Agent integration patterns ✅ COMPLETE
• Best practices for tool descriptions ✅ COMPLETE
• MCP security guide ✅ COMPLETE
• Video: "Your First AI-Native Service in 5 Minutes"

---

Q3 2026: Production & Scale

Status: IN PROGRESS (50%) - Core security and observability features delivered early, infrastructure work remaining

Theme: Run MCP gateways in production at scale

Enterprise MCP Gateway

Create a production-grade standalone MCP gateway:

Gateway Features

• Standalone binary: micro-mcp-gateway
• Horizontal scaling (stateless design)
• Rate limiting per agent/token ✅ (delivered early)
• Usage tracking and analytics
• Cost attribution (track which agent called what) ✅ (audit logging)
• Circuit breakers for service protection ✅ (per-tool, configurable thresholds)
• Request/response caching
• Multi-tenant support (isolate services by namespace)

Deployment:

# Standalone gateway
micro-mcp-gateway \
  --registry consul:8500 \
  --address :3000 \
  --auth jwt \
  --rate-limit 1000/hour \
  --cache redis:6379

Business value: Enterprise customers need production-grade MCP gateways. This is a paid offering.

Observability

• OpenTelemetry integration ✅ (spans, attributes, W3C trace context propagation)
• Agent call tracing (which agent called what) ✅ (trace IDs implemented)
• Tool usage metrics (which tools are popular)
• Performance dashboards
• Anomaly detection (unusual agent behavior)
• Cost analysis (cloud spend per agent)

Dashboard Example:

Agent Activity - Last 7 Days
─────────────────────────────
Claude Desktop    1,234 calls   $12.34 compute cost
ChatGPT Plugin    567 calls     $5.67 compute cost
Custom Agent      234 calls     $2.34 compute cost

Top Services
────────────
users    45%
orders   30%
payments 15%

Slowest Tools
─────────────
analytics.Reports.Generate   2.3s avg
payments.Payments.Process    890ms avg

Business value: Enterprises need observability. This justifies MCP Gateway pricing.

Security ✅ CORE FEATURES COMPLETE (delivered early)

Agent Authentication ✅ COMPLETE

• Auth provider integration (auth.Auth)
• Bearer token authentication
• Scope-based permissions (agent can only call certain services)
• Audit logging (full trail of what agents accessed)
• OAuth2 for agent authorization (basic auth implemented)
• API keys per agent (bearer tokens supported)

Implemented Example:

mcp.Serve(mcp.Options{
    Registry: registry,
    Auth:     authProvider,  // ✅ Implemented
    Scopes: map[string][]string{  // ✅ Implemented
        "blog.Blog.Create": {"blog:write"},
        "blog.Blog.Delete": {"blog:admin"},
    },
    AuditFunc: func(r mcp.AuditRecord) {  // ✅ Implemented
        log.Printf("[audit] %+v", r)
    },
})

Service-Side Authorization ✅ COMPLETE

• Services can validate which agent is calling
• Agent identity in context (via metadata)
• Fine-grained permissions (Agent X can read but not write)
• Trace ID propagation for debugging

Implemented - Metadata in Context:

// Trace ID, Tool Name, and Account ID are automatically
// propagated to services via context metadata:
// - Mcp-Trace-Id
// - Mcp-Tool-Name  
// - Mcp-Account-Id

Future Enhancement - Service-Side Example:

// Future: Direct access to agent info from context
func (s *Users) Delete(ctx context.Context, req *Request, rsp *Response) error {
    // For now, services can read metadata keys:
    // Mcp-Account-Id, Mcp-Trace-Id, Mcp-Tool-Name
    md, _ := metadata.FromContext(ctx)
    accountID := md["Mcp-Account-Id"]
    
    if accountID != "admin-account" {
        return errors.Forbidden("users", "admin only")
    }
    // ...
}

Business value: Security is a hard requirement for enterprise adoption.

Deployment Patterns

Kubernetes Operator

• micro-operator for Kubernetes
• CRD: MCPGateway resource
• Auto-scaling based on agent traffic
• Service mesh integration

Example:

apiVersion: micro.dev/v1
kind: MCPGateway
metadata:
  name: production-gateway
spec:
  registry: consul
  replicas: 3
  rateLimit:
    perAgent: 1000/hour
  observability:
    otel: true
    traces: jaeger:14268

Helm Charts ✅ COMPLETE

• Official Helm chart for MCP gateway (deploy/helm/mcp-gateway/)
• Support for major registries (Consul, etcd, mDNS)
• Ingress configuration with TLS support
• HPA auto-scaling support
• Secrets management

Business value: Easy deployment = faster adoption.

Performance

• Connection pooling for high-throughput
• Response streaming for long-running tools
• Parallel tool execution when agents make multiple calls
• Caching layer for idempotent operations

Target: Support 10,000 concurrent agent requests on a single gateway.

---

Q4 2026: Ecosystem & Monetization

Theme: Build the MCP ecosystem and sustainable business

Agent Marketplace

Create a marketplace of pre-built AI agents that use go-micro services:

Concept

Developers build agents that solve specific problems using microservices:

Examples:

• Customer Support Agent - Integrates with users, tickets, orders services
• DevOps Agent - Integrates with logs, metrics, deployments services
• Sales Agent - Integrates with CRM, leads, analytics services
• Data Analyst Agent - Integrates with analytics, reports services

Format:

# agent.yaml
name: customer-support
description: AI agent that handles customer support tickets
services:
  - users
  - tickets
  - orders
  - payments
prompts:
  - system: "You are a helpful customer support agent..."
  - examples: [...]
mcp:
  gateway: "mcp://services.company.com"
pricing: free|paid

Usage:

# Install agent from marketplace
micro agent install customer-support

# Run agent
micro agent run customer-support

# Agent now has access to your services via MCP

Business value:

• Marketplace fee (15% of paid agents)
• Showcase go-micro capabilities
• Drive framework adoption

Premium Offerings

Build a sustainable business model around open-source core:

Open Source (Free Forever)

• Core framework (go-micro.dev/v5)
• Basic MCP gateway (gateway/mcp)
• CLI (micro run, micro server)
• Documentation and examples
• Community support

Go Micro Cloud (SaaS)

Target: Teams that want managed MCP gateways

Features:

• Managed MCP gateway (no ops required)
• Built-in observability dashboard
• Agent usage analytics
• Multi-region deployment
• 99.9% SLA
• Priority support

Pricing:

• Starter: $99/month (10,000 agent calls/month)
• Team: $499/month (100,000 calls/month)
• Enterprise: Custom (millions of calls/month)

Value proposition: "Don't run your own MCP gateway. We'll do it for you."

Go Micro Enterprise

Target: Large companies deploying at scale

Features:

• On-premise MCP gateway
• SSO integration
• Advanced security (mTLS, Vault integration)
• Custom SLAs
• Dedicated support
• Training and consulting

Pricing:

• Starting at $10,000/year
• Per-seat licensing or infrastructure-based

Value proposition: "Production-grade MCP for your entire organization."

Professional Services

• Custom agent development
• Migration from other frameworks
• Architecture consulting
• Training workshops
• Proof-of-concept projects

Pricing: $200-300/hour

Strategic Integrations

Anthropic Partnership

• Official Anthropic integration guide
• Listed on MCP servers directory
• Co-marketing blog posts
• Featured in Claude documentation
• Joint conference talks

Why: Anthropic created MCP. Being their preferred microservices framework drives adoption.

OpenAI Integration

• ChatGPT plugin format support
• GPTs integration (services as GPT actions)
• OpenAI Assistants API support
• Listed in OpenAI plugin store

Why: OpenAI has largest AI user base. Tap into that market.

Google Gemini

• Gemini API function calling support
• Google Cloud integration guide
• Vertex AI compatibility

Microsoft Copilot

• Copilot Studio integration
• Azure OpenAI compatibility
• Teams bot support

Business value: Every major AI platform can use go-micro services.

Community Growth

Content Strategy

• Monthly blog posts (case studies, tutorials)
• Weekly Twitter/LinkedIn updates
• YouTube channel (tutorials, demos)
• Podcast: "Agents & Services" (interview users)

Events

• "AI-Native Microservices" conference (virtual)
• Monthly community calls
• Hackathons with prizes
• Sponsor AI/agent conferences

Open Source Program

• Contributor rewards (swag, recognition)
• "Agent of the Month" showcase
• Grant program for open-source agents
• University partnerships (courses using go-micro)

Target: Grow from 5K GitHub stars to 15K+ by end of 2026.

---

2027: Platform Dominance

Theme: The AI-native microservices platform

Vision: The Agent Operating System

Go Micro becomes the platform layer between AI and infrastructure:

┌─────────────────────────────────────┐
│         AI Agents Layer              │
│  Claude | GPT | Gemini | Custom     │
└─────────────────────────────────────┘
                 ↓ MCP
┌─────────────────────────────────────┐
│       Go Micro Platform              │
│  Gateway | Registry | Auth | Mesh   │
└─────────────────────────────────────┘
                 ↓ RPC
┌─────────────────────────────────────┐
│      Microservices Layer             │
│  Users | Orders | Payments | ...    │
└─────────────────────────────────────┘

Features

Autonomous Service Discovery

• Agents discover services automatically
• AI-generated service integration code
• Self-healing service mesh
• Zero-config multi-cloud

Agent Orchestration

• Multi-agent workflows built-in
• Agent-to-agent communication via MCP
• Conflict resolution when agents disagree
• Collaborative agents working on tasks

Intelligent Routing

• ML-based service routing (predict best endpoint)
• A/B testing for agents
• Canary deployments driven by agent feedback
• Auto-scaling based on agent behavior

Development Copilot

• AI assistant for service development
• Auto-generate services from requirements
• Suggest optimizations
• Detect bugs before deployment

Example:

$ micro generate "a user authentication service with JWT"

[AI] Analyzing requirements...
[AI] Generating service scaffold...
[AI] Adding JWT auth with RS256...
[AI] Creating database schema...
[AI] Writing tests...
[AI] Service ready: ./auth-service

$ cd auth-service && micro run
[AI] Service running. MCP-enabled. Try asking Claude to create a user!

---

Business Model Deep Dive

Revenue Streams

1. Go Micro Cloud (SaaS) - Primary Revenue

Target ARR: $1M Year 1, $5M Year 2

Customer Segments:

• Startups: Need MCP but don't want to run infrastructure
• Mid-size companies: Building AI features, need reliable MCP gateway
• Enterprises: Multi-region, high-availability requirements

Unit Economics:

• CAC (Customer Acquisition Cost): $500 (content marketing, freemium)
• LTV (Lifetime Value): $12,000 (2-year retention, $500/mo avg)
• LTV:CAC ratio: 24:1 (excellent)

Growth Strategy:

• Freemium model (free tier up to 1,000 calls/month)
• Self-service signup
• Upsell to Team/Enterprise based on usage

2. Enterprise Licenses - High Margin

Target ARR: $500K Year 1, $3M Year 2

Value Proposition:

• On-premise deployment
• Enterprise support
• Custom SLAs
• Training included

Typical Deal:

• $25K-100K/year per company
• 10-20 deals/year = $500K-$2M

3. Professional Services - Consulting

Target Revenue: $250K Year 1, $750K Year 2

Services:

• Agent development (build custom agents)
• Migration consulting (move to go-micro)
• Architecture design
• Training workshops

Pricing:

• $200-300/hour
• 1,000-2,500 billable hours/year

4. Marketplace - Platform Revenue

Target Revenue: $100K Year 1, $500K Year 2

Model:

• Take 15% of paid agent sales
• Host agents for free (community)
• Charge for premium listings

Growth:

• 100 agents by end of 2026
• 10% are paid ($10-100/agent)
• Average sale: $50 × 10 agents × 200 customers = $100K gross
• 15% marketplace fee = $15K net

Total Revenue Projection

• Year 1 (2026): $1.85M

  • SaaS: $1M
  • Enterprise: $500K
  • Services: $250K
  • Marketplace: $100K

• Year 2 (2027): $9.25M (5x growth)

  • SaaS: $5M
  • Enterprise: $3M
  • Services: $750K
  • Marketplace: $500K

Cost Structure

Infrastructure (SaaS)

• Cloud hosting: $50K/year (Year 1) → $250K (Year 2)
• CDN/bandwidth: $10K/year → $50K
• Monitoring/logging: $5K/year → $20K

Team

Year 1 (Lean):

• 2 engineers (full-time): $300K
• 1 DevRel: $120K
• 1 part-time designer: $50K
• Founder (you): sweat equity

Year 2 (Growth):

• 5 engineers: $750K
• 2 DevRel: $240K
• 1 PM: $150K
• 1 sales: $150K
• 1 designer: $100K
• Founder salary: $150K

Marketing

• Content creation: $30K/year
• Conferences/events: $50K/year
• Ads/SEO: $20K/year

Total Costs

• Year 1: $635K
• Year 2: $1.78M

Profitability

• Year 1: $1.85M - $635K = $1.21M profit (65% margin)
• Year 2: $9.25M - $1.78M = $7.47M profit (81% margin)

Why such high margins?

• Software = low marginal cost
• Open-source drives adoption (low CAC)
• Self-service model (low sales cost)
• High customer retention (sticky product)

Funding Strategy

Bootstrap Path (Recommended)

• Start with consulting revenue
• Launch SaaS with freemium model
• Grow organically from profits
• No dilution, full control

VC Path (If Scaling Faster)

• Raise $2M seed at $8M pre-money
• Deploy for:
  • 2x engineering team
  • 2x marketing budget
  • Faster enterprise sales
• Target: $10M ARR in 18 months
• Series A: $15M at $50M valuation

Recommendation: Bootstrap first, then raise Series A if needed for expansion.

---

Success Metrics

Technical KPIs

• 95%+ of Claude Desktop users can add go-micro services (stdio MCP)
• 10,000+ services exposed via MCP in production
• <100ms p99 latency for tool discovery
• Support 10K concurrent agent requests per gateway
• 99.9% MCP gateway uptime

Business KPIs

• $1.85M ARR by end of 2026
• 100+ paying SaaS customers
• 20+ enterprise deals
• 15K+ GitHub stars
• 5K+ Discord members
• 100+ agents in marketplace

Community KPIs

• 50+ conference talks mentioning go-micro + MCP
• 1M+ blog views
• 100+ community-contributed examples
• 20+ case studies published

---

Risk Mitigation

Technical Risks

Risk: MCP protocol changes (Anthropic controls spec)

• Mitigation: Stay involved in MCP working group, implement protocol versions

Risk: Performance issues at scale

• Mitigation: Benchmark early, optimize hot paths, use caching aggressively

Risk: Security vulnerabilities in MCP gateway

• Mitigation: Security audits, bug bounty program, responsible disclosure

Business Risks

Risk: AI hype dies down

• Mitigation: Go Micro still works as regular microservices framework. MCP is additive, not core.

Risk: Competitors build MCP support

• Mitigation: First-mover advantage, best integration, agent marketplace moat

Risk: Cloud providers offer competing solutions

• Mitigation: Open source = no vendor lock-in. We're the community choice.

Market Risks

Risk: Enterprises slow to adopt agents

• Mitigation: Focus on startups first (faster adoption), build proof points

Risk: Different MCP implementations fragment market

• Mitigation: Support multiple protocols, be the most compatible

---

Competitive Landscape

Direct Competitors

• Spring Boot - Java, no MCP support (yet)
• Express.js - JavaScript, minimal microservices support
• gRPC-based frameworks - No MCP support

Our advantage: First-mover in MCP + microservices space.

Indirect Competitors

• API Gateway vendors (Kong, Tyk) - Could add MCP support
• Service meshes (Istio, Linkerd) - Focus on ops, not AI

Our advantage: Purpose-built for agent integration, not retrofitted.

Potential Threats

• AWS/GCP/Azure building managed MCP gateways
• Anthropic launching their own microservices framework

Defense:

• Open source = community ownership
• Best DX (developer experience)
• Agent marketplace = network effects

---

Key Integrations Priority

Tier 1: Must-Have (Q2 2026)

1. Claude Desktop (stdio MCP) - Anthropic's flagship IDE
2. ChatGPT Plugins - Largest user base
3. Kubernetes - Production deployment
4. OpenTelemetry - Observability standard

Tier 2: Important (Q3 2026)

5. LangChain - Popular agent framework
6. Google Gemini - Major AI player
7. Consul/etcd - Service discovery for enterprise
8. Vault - Secrets management

Tier 3: Nice-to-Have (Q4 2026)

9. LlamaIndex - RAG and data
10. AutoGPT - Autonomous agents
11. Microsoft Copilot - Enterprise AI
12. AWS Bedrock - Multi-model platform

---

Sustainability Principles

Open Source Sustainability

1. Core stays free - Framework, basic MCP, CLI always open source
2. Community-first - Features users want, not just what we want to build
3. Transparent roadmap - This document is public
4. Contributor recognition - Credit and compensation for contributions

Business Sustainability

1. Clear value ladder - Free → SaaS → Enterprise (logical upgrade path)
2. High margins - Software business scales without linear costs
3. Multiple revenue streams - Don't depend on one customer segment
4. Profitable by default - Revenue exceeds costs from Year 1

Technical Sustainability

1. Backward compatibility - No breaking changes in v5.x
2. Stable interfaces - MCP gateway API won't change unexpectedly
3. Performance first - Fast by default, not through hacks
4. Documentation - Every feature is documented

---

Call to Action

For Contributors

• Pick a roadmap item
• Open an issue to discuss
• Submit a PR
• Join Discord for coordination

For Users

• Try MCP with your services
• Share feedback (what works, what doesn't)
• Write case studies
• Star the repo ⭐

For Companies

• Become a design partner (help shape roadmap)
• Pilot Go Micro Cloud (early access)
• Sponsor development (your priorities get built first)
• Hire us for consulting

For Investors

• This is a $100M+ opportunity
• Agents need microservices
• We're the first to bridge them
• Contact: [your-email]

---

Conclusion

The future of microservices is AI-native.

API gateways connected apps to services. MCP connects agents to services.

Go Micro is uniquely positioned to own this space:

• ✅ First MCP integration in a major framework
• ✅ Library-first (not just CLI)
• ✅ Production-ready from day one
• ✅ Clear path to monetization

The question isn't whether agents will use microservices. The question is: which framework will they use?

Let's make it Go Micro.

---

Next Steps (March 2026):

1. Complete remaining Q2 items: documentation guides, playground polish
2. Begin Q3 infrastructure: standalone gateway binary, Kubernetes operator
3. Write "Building AI-Native Services" guide and MCP security guide
4. Publish case studies and community content
5. Plan Go Micro Cloud beta launch
6. Explore sustainable business model and product strategy

Questions? Feedback?

• GitHub Discussions: https://github.com/micro/go-micro/discussions
• Discord: https://discord.gg/jwTYuUVAGh

---

This roadmap is a living document. It will evolve based on market feedback, technical discoveries, and community input. Last updated: March 2026.