# 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 - [x] MCP library (`gateway/mcp`) - [x] CLI integration (`micro run --mcp-address`) - [x] Service discovery and tool generation - [x] HTTP/SSE transport - [x] Documentation and examples - [x] 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) - [x] Implement stdio JSON-RPC protocol - [x] Auto-detection: stdio vs HTTP based on environment - [x] `micro mcp` command for Claude Code integration - [x] Example: Add go-micro services to Claude Code **Why:** Claude Code and other local AI tools use stdio MCP servers. This enables: ```bash # 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) - [x] Parse Go comments to generate tool descriptions - [x] Support JSDoc-style tags: `@param`, `@return`, `@example` - [x] 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 - [x] WebSocket transport for streaming (JSON-RPC 2.0, bidirectional) - [ ] gRPC reflection for MCP (bidirectional streaming) - [x] 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 - [x] `langchain-go-micro` Python package - [x] Auto-generate LangChain tools from registry - [x] Example: Multi-agent workflow with go-micro services - [x] Published to contrib/langchain-go-micro/ #### AI Package ✅ COMPLETE - [x] `ai.Model` interface with Generate and Stream - [x] Anthropic Claude provider (`ai/anthropic`) - [x] OpenAI GPT provider (`ai/openai`) - [x] Tool execution with auto-calling support - [x] 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 - [x] `go-micro-llamaindex` package - [x] Service discovery as data sources - [x] 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:** ```bash # 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 - [x] "Building AI-Native Services" guide ✅ COMPLETE - [x] Agent integration patterns ✅ COMPLETE - [x] Best practices for tool descriptions ✅ COMPLETE - [x] 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) - [x] Rate limiting per agent/token ✅ (delivered early) - [ ] Usage tracking and analytics - [x] Cost attribution (track which agent called what) ✅ (audit logging) - [x] Circuit breakers for service protection ✅ (per-tool, configurable thresholds) - [ ] Request/response caching - [ ] Multi-tenant support (isolate services by namespace) **Deployment:** ```bash # 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 - [x] OpenTelemetry integration ✅ (spans, attributes, W3C trace context propagation) - [x] 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 - [x] Auth provider integration (auth.Auth) - [x] Bearer token authentication - [x] Scope-based permissions (agent can only call certain services) - [x] Audit logging (full trail of what agents accessed) - [ ] OAuth2 for agent authorization (basic auth implemented) - [ ] API keys per agent (bearer tokens supported) **Implemented Example:** ```go 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 - [x] Services can validate which agent is calling - [x] Agent identity in context (via metadata) - [x] Fine-grained permissions (Agent X can read but not write) - [x] Trace ID propagation for debugging **Implemented - Metadata in Context:** ```go // 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:** ```go // 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:** ```yaml 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 - [x] Official Helm chart for MCP gateway (`deploy/helm/mcp-gateway/`) - [x] Support for major registries (Consul, etcd, mDNS) - [x] Ingress configuration with TLS support - [x] 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:** ```yaml # 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:** ```bash # 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:** ```bash $ 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/WeMU5AGxD --- _This roadmap is a living document. It will evolve based on market feedback, technical discoveries, and community input. Last updated: March 2026._