Breeze pairs a high-throughput HTTP core with a first-party Model Context Protocol server — 40 scoped tools that let an AI agent scaffold a project, generate code, verify it, and debug a live service, the same way a senior engineer would. Native WebSockets, an event bus, durable workflows, distributed tracing, JSON-RPC and OpenAPI come standard.
package main
import (
"runtime"
"github.com/nelthaarion/breeze/v2"
middleware "github.com/nelthaarion/breeze/v2/middlewares"
)
func main() {
router := breeze.NewRouter()
router.Use(middleware.RecoveryMiddleware())
router.Use(middleware.LoggingMiddleware())
router.Handle(breeze.GET, "/", func(ctx *breeze.Context) error {
return ctx.JSON(map[string]string{"status": "ok"})
})
pool := breeze.NewEventLoopWorkerPool(runtime.NumCPU())
app := breeze.New(router, pool)
app.Run(3000, true) // port, multiCore
}// An agent asks a running Breeze service about itself —
// no separate observability stack, just the app answering.
$ curl -H "Authorization: Bearer $TOKEN" \
http://127.0.0.1:2000/mcp/features
{
"server_kind": "app-runtime",
"granted": ["fleet", "runtime"],
"scoped": true,
"tools": [
"breeze_diagnose_service",
"breeze_get_routes",
"breeze_get_recent_errors",
"breeze_get_performance",
"breeze_get_trace",
"breeze_explain_incident"
]
}Most frameworks got an MCP wrapper bolted on after the fact. Breeze's toolchain — the
same one behind the breeze CLI — is exposed to agents directly, with the permission
model, path confinement and structured refusals worked out at the framework level, not left
to whoever writes the wrapper.
--mode generator carries the full toolchain — generate, plan, verify, provision. --mode app-runtime has no mutating tool registered at all, not merely a filtered one. Nothing reaches a tool that was never built.
Every tool belongs to one of 8 categories — generation, introspection, planning, knowledge, verification, runtime, fleet, provisioning. A token minted for fleet,runtime cannot touch generation, and the handshake reports exactly what was granted and what exists.
An out-of-scope call gets a structured tool result naming the missing capability and saying “retrying will not help” — not a generic JSON-RPC error that invites an agent to loop forever reformatting the same request.
Every path a tool touches is resolved through one function that rejects traversal, symlink escapes and Windows junctions — a new tool cannot forget the check because there is no second way to get a usable path.
A deployed application can serve its own read-only MCP endpoint beside real traffic — an agent debugging production reads breeze_diagnose_service, live routes, errors and traces without a second binary.
The same registry that renders /openapi.json renders /llms.txt — one source of facts, so a service’s model-readable index cannot drift from what it actually serves.
One module, opt-in subpackages. Import only the subsystem you use — nothing else is on the hook for it.
A first-party MCP server — not a plugin — exposes 40 scoped tools so an agent can scaffold, generate, verify, debug and provision a real service, in-process or standalone.
Read the docs →Every route’s method, path and payload shape is recorded once and rendered as a model-readable index — a service documents itself for the agents reading it.
Read the docs →Inline execution on the gnet event loop, zero-copy headers, O(1) routing, and a worker pool with real backpressure policies.
Read the docs →A dedicated fast path for upgraded connections, ordered per-connection delivery, and DialWS for outbound peer links.
Read the docs →A zero-reflection typed event bus and a durable, in-process workflow engine with Saga-style compensation and crash recovery.
Read the docs →A 14-page live dashboard, an observability signal model, a diagnostics registry every subsystem reports through, and distributed Fleet tracing.
Read the docs →JSON-RPC 2.0 on its own port, OpenAPI generation with Scalar UI, byte-range video streaming, and an MCP control plane.
Read the docs →OAuth2 login, request binding & validation, twelve built-in middlewares, migrations, and a gnet-backed HTTP client.
Read the docs →breeze_new and breeze_generate lay down a resource, its handlers,
validation and OpenAPI docs — wired, not stubbed.
breeze_verify_project runs the real Go toolchain inside the confined workspace
— compile errors and test failures come back as structured results, not guesses.
provision_service builds and starts a container with its own scoped, workspace-confined breeze-mcp inside — no host mount an agent can request its way into.
Against the running service: breeze_diagnose_service, live routes, recent errors,
and — with Fleet — a distributed trace with a deterministic root cause.
Two lines wire in a 14-page live dashboard: request timeline profiling, an ORM-free query monitor, a routes explorer generated from the same declarations that produce your OpenAPI spec, and one WebSocket carrying every live update — no polling, no Grafana, no separate collector to run.
coll := dashboard.Install(app, router, dashboard.DefaultConfig())
router.Use(coll.Middleware())
// http://localhost:3000/dashboard — admin / adminRequires Go 1.25.13 or later.
go get github.com/nelthaarion/breeze/v2Pulls in gnet v2 for the event loop, go-json for fast marshaling, brotli for compression, and golang-jwt for authentication. Every other subsystem — including the MCP server — is an opt-in subpackage.
go install github.com/nelthaarion/breeze/v2/cmd/breeze@latest
breeze new myapp