README
¶
Microbus.io
Teach Your Agent to Code Microservices
Your coding agent can already code. Microbus teaches it to master the complex domain of distributed systems - the architecture, the patterns, the operational discipline - and produce enterprise-grade microservices, every time.
Precise Code. Faster. At Scale.
Precise code - Each microservice fits entirely in your agent's context window. Skills guide every feature. A single, simple API handles the infrastructure. Your agent codes with complete awareness and zero guesswork.
Faster - Agents implement, test, and iterate in one session, in one process. No containers, no external dependencies, no waiting. Tighter dev-test-debug loops mean fewer mistakes and faster delivery.
At scale - Every microservice is independent. Multiple agents work on different services simultaneously without merge conflicts or coordination overhead.
Get started in minutes. Microbus is free and open source under the Apache 2.0 license.
Why Microbus?
Microservices are the right architecture for most growing systems, but the conventional toolchain is daunting: container orchestration, service meshes, API gateways, distributed tracing pipelines. Microbus replaces that complexity with a single framework where microservices communicate over NATS using familiar HTTP semantics.
Performant - Persistent multiplexed connections deliver up to 10x the throughput of HTTP/1.1, benchmarked on a single machine to run 10,000 microservices at over 100,000 req/sec.
Observable - Distributed tracing, structured logging and metrics are built in from the start, not bolted on after the fact.
Testable - Spin up a full integration test of multiple microservices in a single Go test function, with no containers or external dependencies required.
AI-native - Deep integration with coding agents lets you go from a plain-language prompt to a production-ready microservice with tests in minutes.
Get Started
Prerequisites
- Your favorite coding agent
- Go 1.26+
- NATS messaging bus (required in high-availability production settings, optional during development)
- LGTM OpenTelemetry observability stack (optional)
Bootstrap
Ask your coding agent to bootstrap Microbus:
HEY CLAUDE...
Use curl to download the workflow at https://raw.githubusercontent.com/microbus-io/fabric/refs/heads/main/setup/bootstrap.md and follow it
Take a Tour
The examples directory contains microservices that demonstrate key patterns: hello world, calculator, CRUD with a database, events, authentication and more.
Take the agent-guided tour!
HEY CLAUDE...
Take me through the agent-guided tour
Build Your First Microservice
The step-by-step tutorial walks you through creating a microservice from scratch, covering endpoints, configuration, web handlers and integration tests.
Start a New Project
Ready to build your own solution? Bootstrap a new project from scratch.
Build with a Coding Agent
Microbus is designed to work hand-in-hand with coding agents like Claude Code. The framework's structured project layout and embedded guidance keep the agent's context window small and its output accurate.
Prompt your way to a fully-implemented microservice:
HEY CLAUDE...
Create a new microservice "helloworld"
Create a web handler that prints "Hello, World!"
Create a config for the Greeting, with a default of "Hello". The greeting must start with a capital letter and not be empty
Create a functional endpoint Add that sums up two integers x and y and returns the sum
Fire an event OnDouble when x==y in Add
Create a metric that totals the positive sums in Add, and another that totals the negative sums
Six prompts. Under 10 minutes. 819 lines of code at 87% test coverage.
Learn more about how coding agents work within the Microbus framework.
Agentic Workflows
Microservices often need to collaborate on processes that span multiple steps, branch in parallel, and wait for external input. Microbus includes a built-in workflow engine - the Foreman - that orchestrates these agentic workflows out of the box.
Define your process as a directed graph of tasks. The Foreman handles execution, parallel fan-out and fan-in, state merging, human-in-the-loop interrupts, and automatic recovery from failures. All state is persisted to a SQL database and the entire system is testable in-memory with go test.
HEY CLAUDE...
Add a task VerifyCredit that receives a creditScore int and returns creditVerified bool
Add a task VerifyIdentity that receives ssn string and returns identityVerified bool
Add a workflow CreditApproval that fans out to VerifyCredit and VerifyIdentity in parallel, then fans in to a Decision task
Learn more about building agentic workflows.
Production Ready
Bundle microservices into applications and deploy them to match your scale: as a single binary, a handful of containers, or across availability zones. Microservices communicate via a messaging bus.
Distributed tracing, metrics and structured logging provide precision visibility into system behavior.
Architecture
Your solution is built on top of 5 layers of powerful technologies that together form a robust foundation:
OSS - A curated selection of proven technologies - NATS for messaging, OpenTelemetry for observability, Grafana for visualization - abstracted away by the layers above.
Connector - The Connector is the base construct from which all microservices are derived. It provides a consistent API for transport, observability, configuration and lifecycle management.
Coding agents - Coding agents generate boilerplate, business logic, tests and documentation using embedded skills that guide each feature end to end.
Microservices - Core microservices ship with the framework. Solution microservices implement your business logic. Both are built the same way using the same tools.
Applications - Microservices are bundled into applications according to the desired topology - a single binary, a handful of containers, or across availability zones.
Features
| Transport | |
|---|---|
| Unicast | 1:1 request/response between microservices |
| Multicast | 1:N publish/subscribe |
| Multiplexed connections | Persistent connections with up to 10x HTTP/1.1 throughput |
| Service discovery | Dynamic, no registry required |
| Load balancing | Automatic distribution across replicas |
| Time budget | Cascading timeout propagation |
| Ack or fail fast | Immediate feedback on request delivery |
| Locality-aware routing | Prefer co-located replicas |
| Connectivity check | Liveness detection |
| Short-circuit | In-memory transport for co-located services |
| Observability | |
|---|---|
| Distributed tracing | Cross-service call visualization via OpenTelemetry |
| Structured logging | JSON logging to stderr |
| Metrics | Prometheus-compatible metrics |
| Error capture | Stack traces preserved across service boundaries |
| Developer Experience | |
|---|---|
| Client stubs | Type-safe generated clients |
| Integration testing | Multi-service tests in a single process |
| Static resources | Embedded files via go:embed |
| Events | Decouple services with event-driven patterns |
| Tickers | Recurring scheduled jobs |
| SQL CRUD microservices | Agent-generated database-backed services |
| Runtime | |
|---|---|
| Configuration | Centralized YAML-based config |
| Authorization | JWT-based access control |
| Adaptable topology | Monolith, multi-container, or hybrid |
| OpenAPI | Auto-generated API documentation |
| Distributed caching | Shared cache across replicas |
| Agentic workflows | Multi-step processes with branching, parallelism and interrupts |
| SQL databases | Cross-database support via the Sequel library |
| Graceful shutdown | Drain pending operations before termination |
Documentation
Guides
- Quick start - An agent-guided tour of the examples
- First microservice - Build a microservice step by step
- Coding agents - Leverage AI-assisted development
- New project - Bootstrap a solution from scratch
- New microservice - Add a microservice to your project
- Configuration - Configure microservices
- Integration testing - Test multiple microservices together
- Enabling authorization - Set up JWT-based access control
- Agentic workflows - Build multi-step workflows with tasks and the Foreman
- LLM integration - Connect microservices to LLMs with automatic tool calling
Reference
- Features of a microservice - Endpoints, events, configs, tickers and metrics
- Path arguments - Wildcard and greedy path parameters
- HTTP magic arguments - Fine-grained control over HTTP request/response
- Environment variables - Initialization settings
- NATS connection - Connection and authentication options
- Control subscriptions - Built-in management endpoints
- Deployment environments - PROD, LAB, LOCAL and TESTING modes
- Ports - External and internal ports
- RPC over JSON vs REST - API style comparison
- Local development - Running a full solution in your IDE
- Package catalog - Introduction to Microbus's codebase
Design
- Encapsulation pattern - Why third-party technologies are wrapped
- JSON/HTTP vs Protobuf - Protocol choice rationale
- Out of scope - Deliberate boundaries
- Milestones - Project history and evolution
- Mission statement - Goals and philosophy
Get Involved
We want your feedback. Clone the repo, try things out and let us know what worked for you, what didn't and what you'd like to see improved.
Help us spread the word. Let your peers and the Go community know about Microbus.
Give us a Github star.
Reach out if you'd like to contribute code.
Corporation? Contact us for sponsorship opportunities.
Contact
| Find us at... | |
|---|---|
| Website | www.microbus.io |
| info@microbus.io | |
| Github | github.com/microbus-io |
| linkedin.com/company/microbus-io | |
| Discord | discord.gg/FAJHnGkNqJ |
| r/microbus | |
| YouTube | @microbus-io |
Legal
The Microbus framework is the copyrighted work of various contributors. It is licensed to you free of charge by Microbus LLC - a Delaware limited liability company formed to hold rights to the combined intellectual property of all contributors - under the Apache License 2.0.
Refer to the list of third-party open source software for licensing information of components used by the Microbus framework.
Documentation
¶
There is no documentation for this package.
Source Files
Directories
¶
| Path | Synopsis |
|---|---|
|
Application is a collection of microservices that run in a single process and share the same lifecycle
|
Application is a collection of microservices that run in a single process and share the same lifecycle |
|
Package cfg is used for defining configuration properties.
|
Package cfg is used for defining configuration properties. |
|
Package connector implements the base class of all microservices.
|
Package connector implements the base class of all microservices. |
|
coreservices
|
|
|
control/controlapi
Package controlapi implements the public API of the control.core microservice, including clients and data structures.
|
Package controlapi implements the public API of the control.core microservice, including clients and data structures. |
|
Package dlru implements an LRU cache that is distributed among the peers of a microservice.
|
Package dlru implements an LRU cache that is distributed among the peers of a microservice. |
|
Package env loads environment variables from env.yaml / env.local.yaml files into the real OS environment at package init time, following dotenv conventions.
|
Package env loads environment variables from env.yaml / env.local.yaml files into the real OS environment at package init time, following dotenv conventions. |
|
examples
|
|
|
Package httpx includes various HTTP utilities.
|
Package httpx includes various HTTP utilities. |
|
Package mem uses multiple sync pools of byte slices to provide allocation-free buffers of various sizes.
|
Package mem uses multiple sync pools of byte slices to provide allocation-free buffers of various sizes. |
|
Package openapi declares the registration types (Service and Endpoint) that describe a microservice's externally-visible features, along with Render which converts a Service into an OpenAPI 3.1 Document.
|
Package openapi declares the registration types (Service and Endpoint) that describe a microservice's externally-visible features, along with Render which converts a Service into an OpenAPI 3.1 Document. |
|
Package pub is used for the publishing of requests.
|
Package pub is used for the publishing of requests. |
|
Package service defines the interfaces of a microservice, which the connector implements.
|
Package service defines the interfaces of a microservice, which the connector implements. |
|
Package sub is used for subscribing to handle requests.
|
Package sub is used for subscribing to handle requests. |
|
Package transport implements the substrate used by microservices to communicate with each other.
|
Package transport implements the substrate used by microservices to communicate with each other. |
|
Package trc is used for working with tracing spans.
|
Package trc is used for working with tracing spans. |
|
Package utils is an assortment of independent utilities.
|
Package utils is an assortment of independent utilities. |