docs: align public x402 flag examples

Update README.md
Propagate flow checkpoint failures (#3150 )
2026-06-27 08:08:24 +00:00 · 2026-06-27 07:08:08 +01:00 · 2026-06-27 06:55:56 +01:00 · 2026-06-27 04:55:49 +01:00 · 2026-06-27 03:29:12 +01:00 · 2026-06-27 02:28:39 +01:00
69 changed files with 1967 additions and 252 deletions
@@ -0,0 +1,48 @@
+name: Architecture Review
+
+# Periodic high-altitude review of the whole framework and harness against the
+# North Star (internal/docs/THESIS.md) — part of the autonomous loop
+# (internal/docs/CONTINUOUS_IMPROVEMENT.md). Where DevRel watches the public
+# story, the architect watches the system: API coherence, lifecycle gaps, and
+# whether recent increments are converging on the thesis or sprawling.
+#
+# The architect's OUTPUT is an assessment plus scoped follow-up issues that feed
+# the hourly increment loop — NOT large refactors. Breaking public-API and
+# architectural changes stay with the human (see CONTINUOUS_IMPROVEMENT.md).
+#
+# Opens a fresh issue and dispatches Codex via CODEX_TRIGGER_TOKEN.
+
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "0 8 */3 * *" # roughly every 3 days, 08:00 UTC (tunable)
+
+permissions:
+  issues: write
+
+concurrency:
+  group: architecture-review
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open an architecture review issue and dispatch Codex
+        env:
+          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
+          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
+          REPO: ${{ github.repository }}
+          RUN_NUMBER: ${{ github.run_number }}
+        run: |
+          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
+            echo "CODEX_TRIGGER_TOKEN is not set — skipping (Codex ignores Actions-bot comments)."
+            exit 0
+          fi
+          ISSUE_URL=$(gh issue create --repo "$REPO" \
+            --title "Architecture review #$RUN_NUMBER" \
+            --body "Periodic architecture / harness review against the North Star in internal/docs/THESIS.md. Output: an assessment plus scoped follow-up issues for the increment loop.")
+          ISSUE_NUM="${ISSUE_URL##*/}"
+          echo "Opened issue #$ISSUE_NUM — dispatching Codex (Architect)."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "@codex Act as the architect for go-micro. Review the overall framework and harness against the North Star in internal/docs/THESIS.md (services → agents → workflows as one runtime) and the roadmap in ROADMAP.md. Assess: API coherence and consistency across the core packages (agent, ai, flow, gateway/mcp, gateway/a2a, model, server, store, registry), gaps or missing pieces in the services → agents → workflows lifecycle, duplication or drift, and whether recent increments (scan recently merged PRs) are converging on the thesis or sprawling. Then: (A) post a concise architectural assessment as a comment on this issue (#$ISSUE_NUM) — strengths, the top risks/gaps, and a recommended direction for the next increments; (B) file concrete, scoped follow-up issues for the highest-value gaps so the hourly increment loop can pick them up — \`gh issue create --label codex --label enhancement --title \"<scoped task>\" --body \"<goal, scope, acceptance criteria>\"\` (each must be a single, self-contained, CI-verifiable chunk). Do NOT make breaking public-API or architectural changes yourself — your output is the assessment and the issues. A small, safe doc/comment correction may be a PR (\`git switch -c codex/architect-$ISSUE_NUM\` … \`gh pr create --base master --label codex …\` … \`gh pr merge --squash --auto --delete-branch\`). Do not use the make_pr tool (it is a no-op stub)."
@@ -0,0 +1,47 @@
+name: DevRel Review
+
+# Daily higher-altitude coherence pass over the PUBLIC surface — README,
+# website (landing + docs), and blog — part of the autonomous loop
+# (internal/docs/CONTINUOUS_IMPROVEMENT.md). The hourly increment loop ships
+# code; this keeps the story coherent: docs/website aligned, README crisp, and
+# a steady supply of things worth blogging about.
+#
+# Like the increment loop it opens a fresh issue and dispatches Codex via
+# CODEX_TRIGGER_TOKEN (Codex ignores Actions-bot comments). Autonomy boundary:
+# SAFE factual-alignment and crispness fixes auto-merge; brand/positioning copy
+# and blog drafts are surfaced in the report for the human, never auto-merged.
+
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "0 7 * * *" # daily, 07:00 UTC (tunable)
+
+permissions:
+  issues: write
+
+concurrency:
+  group: devrel-review
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open a DevRel review issue and dispatch Codex
+        env:
+          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
+          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
+          REPO: ${{ github.repository }}
+          RUN_NUMBER: ${{ github.run_number }}
+        run: |
+          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
+            echo "CODEX_TRIGGER_TOKEN is not set — skipping (Codex ignores Actions-bot comments)."
+            exit 0
+          fi
+          ISSUE_URL=$(gh issue create --repo "$REPO" \
+            --title "DevRel coherence review #$RUN_NUMBER" \
+            --body "Daily DevRel / coherence pass over README, website (landing + docs), and the blog. North Star: internal/docs/THESIS.md.")
+          ISSUE_NUM="${ISSUE_URL##*/}"
+          echo "Opened issue #$ISSUE_NUM — dispatching Codex (DevRel)."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "@codex Act as DevRel for go-micro. Audit the PUBLIC surface — \`README.md\`, \`internal/website/\` (landing \`index.html\` + \`docs/\`), and the blog under \`internal/website/blog/\` — for coherence with the North Star in internal/docs/THESIS.md (an agent harness and service framework; the services → agents → workflows lifecycle). Look for: (1) places where README / website / docs contradict each other, are stale, or describe behavior that has since changed (cross-check against the code and recent merged PRs / CHANGELOG.md); (2) whether the README is crisp and leads with the harness positioning; (3) one to three genuinely blog-worthy items from recently shipped work. Then do BOTH of these: (A) post a concise findings report as a comment on this issue (#$ISSUE_NUM) — what is aligned, what drifted, what you fixed, and the blog ideas; (B) for SAFE factual-alignment and crispness fixes only (NOT brand/marketing/positioning rewrites), open one PR: \`git switch -c codex/devrel-$ISSUE_NUM\`, \`git push -u origin codex/devrel-$ISSUE_NUM\`, \`gh pr create --base master --label codex --title \"<title>\" --body \"<summary, including 'Closes #$ISSUE_NUM'>\"\`, then \`gh pr merge --squash --auto --delete-branch\`. Leave brand/positioning copy and blog drafts for the human — describe them in the report, do NOT open auto-merging PRs for them. Do not use the make_pr tool (it is a no-op stub). If you touch code, verify go build/test/golangci-lint. Stay out of breaking public-API changes."
@@ -27,11 +27,13 @@ jobs:
          cache: true
      - name: Build
        run: go build ./...
+      - name: 0→1 scaffold contract
+        run: go test ./cmd/micro/cli/new -run TestZeroToOneContract -count=1
      - name: Universe end-to-end (asserts; exits non-zero on failure)
        run: go run ./internal/harness/universe
      - name: Agent-flow harness
        run: go run ./internal/harness/agent-flow
-      - name: Plan-delegate harness
+      - name: 0→hero plan-delegate workflow harness
        run: go run ./internal/harness/plan-delegate

  harness-live:
@@ -57,4 +59,19 @@ jobs:
          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
          TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
          ATLASCLOUD_API_KEY: ${{ secrets.ATLASCLOUD_API_KEY }}
-        run: go run ./internal/harness/provider-conformance -require-configured
+        run: |
+          go run ./internal/harness/provider-conformance \
+            -require-configured \
+            -summary-json provider-conformance-summary.json \
+            -summary-markdown provider-conformance-summary.md \
+            -capabilities-markdown provider-capabilities.md
+      - name: Upload provider conformance summary
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: provider-conformance
+          path: |
+            provider-conformance-summary.json
+            provider-conformance-summary.md
+            provider-capabilities.md
+          if-no-files-found: ignore
@@ -7,6 +7,7 @@ on:
    types:
      - opened
      - reopened
+      - synchronize
    branches:
      - "**"
 jobs:
@@ -47,7 +47,7 @@ test-coverage:
 harness:
 	go run ./internal/harness/universe
 	go run ./internal/harness/agent-flow
-	go run ./internal/harness/plan-delegate
+	go run ./internal/harness/plan-delegate # 0→hero: services + agents + flow + plan/delegate

 # Run the same harnesses against every configured live provider. Providers
 # without API keys are skipped; configured providers must pass.
@@ -2,7 +2,9 @@

 Go Micro is an **agent harness** and service framework for Go.

-A harness is the runtime around an agent: the tools it can call, the memory it keeps, the guardrails that bound it, the workflows that trigger it, the services it depends on, and the protocols other agents use to reach it. Go Micro gives you that harness as Go code. Build an agent and it gets a model, memory, tools, planning, delegation, guardrails, and service discovery; it is reachable over [MCP](https://modelcontextprotocol.io/) and [A2A](https://a2a-protocol.org). Write services and every endpoint becomes an AI-callable tool. Orchestrate the deterministic parts with durable flows. Agents, services, and flows share one runtime because an agent is a distributed system, and building one is building a service.
+A harness is the runtime around an agent: the tools it can call, the memory it keeps, the guardrails that bound it, the workflows that trigger it, the services it depends on, and the protocols other agents use to reach it. 
+
+Go Micro gives you the harness as Go code. Build an agent and it gets a model, memory, tools, planning, delegation, guardrails, and service discovery; it is reachable over [MCP](https://modelcontextprotocol.io/) and [A2A](https://a2a-protocol.org). Write services and every endpoint becomes an AI-callable tool. Orchestrate the deterministic parts with durable flows. Agents, services, and flows share one runtime because an agent is a distributed system, and building one is building a service.

 ## Sponsors

@@ -253,9 +255,9 @@ Every endpoint is an AI-callable tool — and it can be a *paid* tool. Go Micro

 ```bash
 # Charge for tool calls at the MCP gateway (off unless you set a pay-to address)
-micro mcp serve --x402-pay-to 0xYourAddress --x402-network solana --x402-amount 10000
+micro mcp serve --x402_pay_to 0xYourAddress --x402_network solana --x402_amount 10000
 # Per-tool amounts via a config file
-micro mcp serve --x402-config x402.json
+micro mcp serve --x402_config x402.json
 ```

 See the [Payments (x402) guide](internal/website/docs/guides/x402-payments.md).
@@ -136,7 +136,7 @@ func (a *agentImpl) setup() {
 	a.tools = ai.NewTools(a.opts.Registry, ai.ToolClient(a.opts.Client))
 	modelOpts = append(modelOpts, ai.WithToolHandler(a.toolHandler()))
 	a.model = ai.New(a.opts.Provider, modelOpts...)
-	if a.opts.TraceProvider != nil && a.model != nil {
+	if a.model != nil {
 		a.model = a.tracedModel(a.model)
 	}

@@ -168,6 +168,10 @@ func (a *agentImpl) stateStore() store.Store {
 // Ask sends a message and returns the agent's response.
 // This is the programmatic API for direct use.
 func (a *agentImpl) Ask(ctx context.Context, message string) (*Response, error) {
+	return a.ask(ctx, message, a.parentRunID)
+}
+
+func (a *agentImpl) ask(ctx context.Context, message, parentRunID string) (*Response, error) {
 	a.mu.Lock()
 	defer a.mu.Unlock()

@@ -188,7 +192,7 @@ func (a *agentImpl) Ask(ctx context.Context, message string) (*Response, error)
 	a.runID = uuid.New().String()
 	ctx = ai.WithRunInfo(ctx, ai.RunInfo{
 		RunID:    a.runID,
-		ParentID: a.parentRunID,
+		ParentID: parentRunID,
 		Agent:    a.opts.Name,
 	})
 	ctx, endRun := a.startRun(ctx, message)
@@ -228,19 +232,21 @@ func (a *agentImpl) Ask(ctx context.Context, message string) (*Response, error)
 		ToolCalls: resp.ToolCalls,
 		Agent:     a.opts.Name,
 		RunID:     a.runID,
-		ParentID:  a.parentRunID,
+		ParentID:  parentRunID,
 	}, nil
 }

 // Chat implements the proto AgentHandler interface for RPC.
 // @example {"message": "What tasks are overdue?"}
 func (a *agentImpl) Chat(ctx context.Context, req *pb.ChatRequest, rsp *pb.ChatResponse) error {
-	resp, err := a.Ask(ctx, req.Message)
+	resp, err := a.ask(ctx, req.Message, req.ParentId)
 	if err != nil {
 		return err
 	}
 	rsp.Reply = resp.Reply
 	rsp.Agent = resp.Agent
+	rsp.RunId = resp.RunID
+	rsp.ParentId = resp.ParentID
 	for _, tc := range resp.ToolCalls {
 		input, _ := json.Marshal(tc.Input)
 		rsp.ToolCalls = append(rsp.ToolCalls, &pb.ToolCall{
@@ -1,7 +1,11 @@
 package agent

 import (
+	"context"
 	"testing"
+
+	pb "go-micro.dev/v6/agent/proto"
+	"go-micro.dev/v6/ai"
 )

 func TestNew(t *testing.T) {
@@ -34,6 +38,51 @@ func TestNew(t *testing.T) {
 	}
 }

+func TestChatResponseIncludesRunIDs(t *testing.T) {
+	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
+		return &ai.Response{Reply: "ok"}, nil
+	}
+	defer func() { fakeGen = nil }()
+
+	a := newTestAgent(Name("chat-run"))
+	var rsp pb.ChatResponse
+	if err := a.Chat(context.Background(), &pb.ChatRequest{Message: "hello"}, &rsp); err != nil {
+		t.Fatalf("Chat: %v", err)
+	}
+	if rsp.RunId == "" {
+		t.Fatal("Chat response RunId is empty")
+	}
+	if rsp.Agent != "chat-run" {
+		t.Errorf("Agent = %q, want chat-run", rsp.Agent)
+	}
+	if rsp.ParentId != "" {
+		t.Errorf("ParentId = %q, want empty", rsp.ParentId)
+	}
+}
+
+func TestChatRequestParentIDPropagatesToResponse(t *testing.T) {
+	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
+		info, ok := ai.RunInfoFrom(ctx)
+		if !ok {
+			t.Fatal("RunInfo missing from model context")
+		}
+		if info.ParentID != "flow-run-123" {
+			t.Fatalf("RunInfo.ParentID = %q, want flow-run-123", info.ParentID)
+		}
+		return &ai.Response{Reply: "ok"}, nil
+	}
+	defer func() { fakeGen = nil }()
+
+	a := newTestAgent(Name("chat-child"))
+	var rsp pb.ChatResponse
+	if err := a.Chat(context.Background(), &pb.ChatRequest{Message: "hello", ParentId: "flow-run-123"}, &rsp); err != nil {
+		t.Fatalf("Chat: %v", err)
+	}
+	if rsp.ParentId != "flow-run-123" {
+		t.Errorf("ParentId = %q, want flow-run-123", rsp.ParentId)
+	}
+}
+
 func TestBuildPrompt(t *testing.T) {
 	// Custom prompt
 	a := New(Name("test"), Prompt("custom prompt")).(*agentImpl)
@@ -108,6 +108,7 @@ func (a *agentImpl) toolHandler() ai.ToolHandler {
 	h = a.loopWrap(h)
 	h = a.stepWrap(h)
 	h = a.planWrap(h)
+	h = contextWrap(h)
 	h = a.traceTool(h)
 	for i := len(a.opts.wrappers) - 1; i >= 0; i-- {
 		h = a.opts.wrappers[i](h)
@@ -115,6 +116,21 @@ func (a *agentImpl) toolHandler() ai.ToolHandler {
 	return h
 }

+// contextWrap stops tool execution promptly when the Ask context has
+// already been canceled or its deadline has expired. This keeps guardrail
+// bookkeeping and side-effecting tools from running after the caller has
+// abandoned the agent run.
+func contextWrap(next ai.ToolHandler) ai.ToolHandler {
+	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
+		select {
+		case <-ctx.Done():
+			return errResult(call.ID, ctx.Err().Error())
+		default:
+		}
+		return next(ctx, call)
+	}
+}
+
 // baseHandler executes a tool call: a developer custom tool, the built-in
 // delegate, or an RPC to the service. It is the innermost handler.
 func (a *agentImpl) baseHandler() ai.ToolHandler {
@@ -250,8 +250,9 @@ func WithTool(name, description string, properties map[string]any, handler ToolF
 	}
 }

-// TraceProvider enables OpenTelemetry tracing for agent runs. When nil,
-// agent tracing and run timeline recording are disabled.
+// TraceProvider enables OpenTelemetry tracing for agent runs. The persisted
+// run timeline is recorded even when TraceProvider is nil; trace/span IDs are
+// added only when a provider is configured.
 func TraceProvider(tp trace.TracerProvider) Option {
 	return func(o *Options) { o.TraceProvider = tp }
 }
@@ -62,6 +62,10 @@ type RunListOptions struct {
 	// Status, when set, keeps only runs with the matching status
 	// (for example "running", "done", "error", or "refused").
 	Status string
+	// TraceID, when set, keeps only runs correlated with this trace id.
+	// A prefix is accepted so operators can paste the shortened trace id
+	// printed by `micro runs`.
+	TraceID string
 	// Limit, when positive, returns the most recently updated runs up to
 	// the limit. Limited results are ordered newest first.
 	Limit int
@@ -88,13 +92,23 @@ func (a *agentImpl) tracer() trace.Tracer {
 }

 func (a *agentImpl) startRun(ctx context.Context, message string) (context.Context, func(error)) {
-	if a.opts.TraceProvider == nil {
-		return ctx, func(error) {}
-	}
 	info, _ := ai.RunInfoFrom(ctx)
+	start := time.Now()
+
+	if a.opts.TraceProvider == nil {
+		a.recordRunEvent(RunEvent{Time: start, RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "run", Name: message})
+		return ctx, func(err error) {
+			latency := time.Since(start).Milliseconds()
+			if err != nil {
+				a.recordRunEvent(RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "error", LatencyMS: latency, Error: err.Error()})
+				return
+			}
+			a.recordRunEvent(RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "done", LatencyMS: latency})
+		}
+	}
+
 	ctx, span := a.tracer().Start(ctx, spanNameRun, trace.WithSpanKind(trace.SpanKindInternal), trace.WithAttributes(
 		attribute.String(AttrRunID, info.RunID), attribute.String(AttrParentRunID, info.ParentID), attribute.String(AttrAgentName, info.Agent)))
-	start := time.Now()
 	a.recordSpanEvent(span, RunEvent{Time: start, RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "run", Name: message})
 	return ctx, func(err error) {
 		latency := time.Since(start).Milliseconds()
@@ -118,14 +132,33 @@ type tracedModel struct {

 func (a *agentImpl) tracedModel(m ai.Model) ai.Model { return &tracedModel{Model: m, a: a} }
 func (m *tracedModel) Generate(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (*ai.Response, error) {
-	if m.a.opts.TraceProvider == nil {
-		return m.Model.Generate(ctx, req, opts...)
-	}
 	info, _ := ai.RunInfoFrom(ctx)
 	provider := m.String()
 	model := m.Options().Model
-	ctx, span := m.a.tracer().Start(ctx, spanNameModelCall, trace.WithAttributes(attribute.String(AttrProvider, provider), attribute.String(AttrModel, model)))
 	start := time.Now()
+
+	if m.a.opts.TraceProvider == nil {
+		resp, err := m.Model.Generate(ctx, req, opts...)
+		dur := time.Since(start).Milliseconds()
+		usage := ai.Usage{}
+		if resp != nil {
+			usage = resp.Usage
+		}
+		e := RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "model", Provider: provider, Model: model, LatencyMS: dur, Tokens: usage}
+		if err != nil {
+			e.Error = err.Error()
+		}
+		m.a.recordRunEvent(e)
+		return resp, err
+	}
+
+	ctx, span := m.a.tracer().Start(ctx, spanNameModelCall, trace.WithAttributes(
+		attribute.String(AttrRunID, info.RunID),
+		attribute.String(AttrParentRunID, info.ParentID),
+		attribute.String(AttrAgentName, info.Agent),
+		attribute.String(AttrProvider, provider),
+		attribute.String(AttrModel, model),
+	))
 	resp, err := m.Model.Generate(ctx, req, opts...)
 	dur := time.Since(start).Milliseconds()
 	attrs := []attribute.KeyValue{attribute.Int64(AttrLatencyMS, dur)}
@@ -164,13 +197,24 @@ func appendUsage(attrs []attribute.KeyValue, u ai.Usage) []attribute.KeyValue {
 }

 func (a *agentImpl) traceTool(next ai.ToolHandler) ai.ToolHandler {
-	if a.opts.TraceProvider == nil {
-		return next
-	}
 	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
 		info, _ := ai.RunInfoFrom(ctx)
-		ctx, span := a.tracer().Start(ctx, spanNameToolCall, trace.WithAttributes(attribute.String(AttrToolName, call.Name), attribute.Bool(AttrDelegate, call.Name == toolDelegate)))
 		start := time.Now()
+
+		if a.opts.TraceProvider == nil {
+			res := next(ctx, call)
+			dur := time.Since(start).Milliseconds()
+			a.recordRunEvent(RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "tool", Name: call.Name, LatencyMS: dur, Refused: res.Refused, Error: resultError(res)})
+			return res
+		}
+
+		ctx, span := a.tracer().Start(ctx, spanNameToolCall, trace.WithAttributes(
+			attribute.String(AttrRunID, info.RunID),
+			attribute.String(AttrParentRunID, info.ParentID),
+			attribute.String(AttrAgentName, info.Agent),
+			attribute.String(AttrToolName, call.Name),
+			attribute.Bool(AttrDelegate, call.Name == toolDelegate),
+		))
 		res := next(ctx, call)
 		dur := time.Since(start).Milliseconds()
 		attrs := []attribute.KeyValue{attribute.Int64(AttrLatencyMS, dur)}
@@ -213,7 +257,7 @@ func (a *agentImpl) recordSpanEvent(span trace.Span, e RunEvent) {
 }

 func (a *agentImpl) recordRunEvent(e RunEvent) {
-	if a.opts.TraceProvider == nil || e.RunID == "" {
+	if e.RunID == "" {
 		return
 	}
 	b, _ := json.Marshal(e)
@@ -292,6 +336,9 @@ func ListRunSummariesWithOptions(s store.Store, agentName string, opts RunListOp
 		if opts.Status != "" && summary.Status != opts.Status {
 			continue
 		}
+		if opts.TraceID != "" && !strings.HasPrefix(summary.TraceID, opts.TraceID) {
+			continue
+		}
 		summaries = append(summaries, summary)
 	}
 	if opts.Limit > 0 {
@@ -8,6 +8,7 @@ import (

 	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/store"
+	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/sdk/trace"
 	"go.opentelemetry.io/otel/sdk/trace/tracetest"
 )
@@ -46,16 +47,33 @@ func TestAgentOpenTelemetrySpans(t *testing.T) {
 	}
 	spans := exp.GetSpans().Snapshots()
 	want := map[string]bool{spanNameRun: false, spanNameModelCall: false, spanNameToolCall: false}
+	var runID string
 	for _, s := range spans {
 		if _, ok := want[s.Name()]; ok {
 			want[s.Name()] = true
 		}
+		attrs := spanAttributes(s.Attributes())
+		if s.Name() == spanNameRun {
+			runID = attrs[AttrRunID]
+		}
 	}
 	for name, seen := range want {
 		if !seen {
 			t.Fatalf("span %s not emitted; got %d spans", name, len(spans))
 		}
 	}
+	if runID == "" {
+		t.Fatal("run span missing run id attribute")
+	}
+	for _, s := range spans {
+		if s.Name() != spanNameModelCall && s.Name() != spanNameToolCall {
+			continue
+		}
+		attrs := spanAttributes(s.Attributes())
+		if attrs[AttrRunID] != runID || attrs[AttrAgentName] != "runner" {
+			t.Fatalf("%s missing run correlation attributes: %#v", s.Name(), attrs)
+		}
+	}
 	keys, err := store.Scope(st, "agent", "runner").List(store.ListPrefix("runs/"))
 	if err != nil {
 		t.Fatal(err)
@@ -91,7 +109,15 @@ func TestAgentOpenTelemetrySpans(t *testing.T) {
 	}
 }

-func TestAgentOpenTelemetryNoopWhenUnconfigured(t *testing.T) {
+func spanAttributes(attrs []attribute.KeyValue) map[string]string {
+	out := make(map[string]string, len(attrs))
+	for _, attr := range attrs {
+		out[string(attr.Key)] = attr.Value.AsString()
+	}
+	return out
+}
+
+func TestAgentRunTimelineRecordsModelAndToolWithoutTraceProvider(t *testing.T) {
 	st := store.NewMemoryStore()
 	a := New(Name("runner-noop"), Provider("oteltest"), WithStore(st), WithTool("probe", "probe", nil, func(context.Context, map[string]any) (string, error) { return "ok", nil }))
 	if _, err := a.Ask(context.Background(), "hello"); err != nil {
@@ -101,11 +127,37 @@ func TestAgentOpenTelemetryNoopWhenUnconfigured(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(keys) != 0 {
-		t.Fatalf("expected no run timeline without TraceProvider, got %v", keys)
+	if len(keys) == 0 {
+		t.Fatal("expected run timeline without TraceProvider")
 	}
-	if _, ok := a.(*agentImpl).model.(*tracedModel); ok {
-		t.Fatal("model should not be wrapped when TraceProvider is nil")
+	summaries, err := ListRunSummaries(st, "runner-noop")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(summaries) != 1 {
+		t.Fatalf("got %d summaries, want 1", len(summaries))
+	}
+	if summaries[0].Status != "done" || summaries[0].LastKind != "done" {
+		t.Fatalf("unexpected summary without TraceProvider: %#v", summaries[0])
+	}
+	if summaries[0].TraceID != "" || summaries[0].SpanID != "" {
+		t.Fatalf("unexpected trace correlation without TraceProvider: %#v", summaries[0])
+	}
+	events, err := LoadRunEvents(st, "runner-noop", summaries[0].RunID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen := map[string]bool{"run": false, "model": false, "tool": false, "done": false}
+	for _, e := range events {
+		seen[e.Kind] = true
+		if e.TraceID != "" || e.SpanID != "" {
+			t.Fatalf("event has trace correlation without TraceProvider: %#v", e)
+		}
+	}
+	for kind, ok := range seen {
+		if !ok {
+			t.Fatalf("missing %s event in timeline: %#v", kind, events)
+		}
 	}
 }

@@ -184,7 +236,7 @@ func TestListRunSummariesWithOptionsFiltersAndLimits(t *testing.T) {
 	events := []RunEvent{
 		{Time: time.Unix(0, 1), RunID: "run-old", Agent: "runner", Kind: "run"},
 		{Time: time.Unix(0, 2), RunID: "run-old", Agent: "runner", Kind: "done"},
-		{Time: time.Unix(0, 3), RunID: "run-new", Agent: "runner", Kind: "run"},
+		{Time: time.Unix(0, 3), RunID: "run-new", Agent: "runner", TraceID: "abcdef1234567890", Kind: "run"},
 		{Time: time.Unix(0, 4), RunID: "run-new", Agent: "runner", Kind: "error", Error: "boom"},
 	}
 	for _, e := range events {
@@ -197,7 +249,7 @@ func TestListRunSummariesWithOptionsFiltersAndLimits(t *testing.T) {
 		}
 	}

-	got, err := ListRunSummariesWithOptions(st, "runner", RunListOptions{Status: "error", Limit: 1})
+	got, err := ListRunSummariesWithOptions(st, "runner", RunListOptions{Status: "error", TraceID: "abcdef", Limit: 1})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2,7 +2,7 @@
 // versions:
 // 	protoc-gen-go v1.36.11
 // 	protoc        v3.21.12
-// source: proto/agent.proto
+// source: agent/proto/agent.proto

 package agent

@@ -22,15 +22,17 @@ const (
 )

 type ChatRequest struct {
-	state         protoimpl.MessageState `protogen:"open.v1"`
-	Message       string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
+	state   protoimpl.MessageState `protogen:"open.v1"`
+	Message string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
+	// parent_id correlates this chat with the workflow or agent run that dispatched it.
+	ParentId      string `protobuf:"bytes,2,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }

 func (x *ChatRequest) Reset() {
 	*x = ChatRequest{}
-	mi := &file_proto_agent_proto_msgTypes[0]
+	mi := &file_agent_proto_agent_proto_msgTypes[0]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -42,7 +44,7 @@ func (x *ChatRequest) String() string {
 func (*ChatRequest) ProtoMessage() {}

 func (x *ChatRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_agent_proto_msgTypes[0]
+	mi := &file_agent_proto_agent_proto_msgTypes[0]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -55,7 +57,7 @@ func (x *ChatRequest) ProtoReflect() protoreflect.Message {

 // Deprecated: Use ChatRequest.ProtoReflect.Descriptor instead.
 func (*ChatRequest) Descriptor() ([]byte, []int) {
-	return file_proto_agent_proto_rawDescGZIP(), []int{0}
+	return file_agent_proto_agent_proto_rawDescGZIP(), []int{0}
 }

 func (x *ChatRequest) GetMessage() string {
@@ -65,18 +67,29 @@ func (x *ChatRequest) GetMessage() string {
 	return ""
 }

+func (x *ChatRequest) GetParentId() string {
+	if x != nil {
+		return x.ParentId
+	}
+	return ""
+}
+
 type ChatResponse struct {
-	state         protoimpl.MessageState `protogen:"open.v1"`
-	Reply         string                 `protobuf:"bytes,1,opt,name=reply,proto3" json:"reply,omitempty"`
-	Agent         string                 `protobuf:"bytes,2,opt,name=agent,proto3" json:"agent,omitempty"`
-	ToolCalls     []*ToolCall            `protobuf:"bytes,3,rep,name=tool_calls,json=toolCalls,proto3" json:"tool_calls,omitempty"`
+	state     protoimpl.MessageState `protogen:"open.v1"`
+	Reply     string                 `protobuf:"bytes,1,opt,name=reply,proto3" json:"reply,omitempty"`
+	Agent     string                 `protobuf:"bytes,2,opt,name=agent,proto3" json:"agent,omitempty"`
+	ToolCalls []*ToolCall            `protobuf:"bytes,3,rep,name=tool_calls,json=toolCalls,proto3" json:"tool_calls,omitempty"`
+	// run_id correlates this chat response with tool calls, traces, and run history.
+	RunId string `protobuf:"bytes,4,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
+	// parent_id is set when this response belongs to a delegated sub-agent run.
+	ParentId      string `protobuf:"bytes,5,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }

 func (x *ChatResponse) Reset() {
 	*x = ChatResponse{}
-	mi := &file_proto_agent_proto_msgTypes[1]
+	mi := &file_agent_proto_agent_proto_msgTypes[1]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -88,7 +101,7 @@ func (x *ChatResponse) String() string {
 func (*ChatResponse) ProtoMessage() {}

 func (x *ChatResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_agent_proto_msgTypes[1]
+	mi := &file_agent_proto_agent_proto_msgTypes[1]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -101,7 +114,7 @@ func (x *ChatResponse) ProtoReflect() protoreflect.Message {

 // Deprecated: Use ChatResponse.ProtoReflect.Descriptor instead.
 func (*ChatResponse) Descriptor() ([]byte, []int) {
-	return file_proto_agent_proto_rawDescGZIP(), []int{1}
+	return file_agent_proto_agent_proto_rawDescGZIP(), []int{1}
 }

 func (x *ChatResponse) GetReply() string {
@@ -125,6 +138,20 @@ func (x *ChatResponse) GetToolCalls() []*ToolCall {
 	return nil
 }

+func (x *ChatResponse) GetRunId() string {
+	if x != nil {
+		return x.RunId
+	}
+	return ""
+}
+
+func (x *ChatResponse) GetParentId() string {
+	if x != nil {
+		return x.ParentId
+	}
+	return ""
+}
+
 type ToolCall struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
@@ -137,7 +164,7 @@ type ToolCall struct {

 func (x *ToolCall) Reset() {
 	*x = ToolCall{}
-	mi := &file_proto_agent_proto_msgTypes[2]
+	mi := &file_agent_proto_agent_proto_msgTypes[2]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -149,7 +176,7 @@ func (x *ToolCall) String() string {
 func (*ToolCall) ProtoMessage() {}

 func (x *ToolCall) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_agent_proto_msgTypes[2]
+	mi := &file_agent_proto_agent_proto_msgTypes[2]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -162,7 +189,7 @@ func (x *ToolCall) ProtoReflect() protoreflect.Message {

 // Deprecated: Use ToolCall.ProtoReflect.Descriptor instead.
 func (*ToolCall) Descriptor() ([]byte, []int) {
-	return file_proto_agent_proto_rawDescGZIP(), []int{2}
+	return file_agent_proto_agent_proto_rawDescGZIP(), []int{2}
 }

 func (x *ToolCall) GetId() string {
@@ -193,18 +220,21 @@ func (x *ToolCall) GetResult() string {
 	return ""
 }

-var File_proto_agent_proto protoreflect.FileDescriptor
+var File_agent_proto_agent_proto protoreflect.FileDescriptor

-const file_proto_agent_proto_rawDesc = "" +
+const file_agent_proto_agent_proto_rawDesc = "" +
 	"\n" +
-	"\x11proto/agent.proto\x12\x05agent\"'\n" +
+	"\x17agent/proto/agent.proto\x12\x05agent\"D\n" +
 	"\vChatRequest\x12\x18\n" +
-	"\amessage\x18\x01 \x01(\tR\amessage\"j\n" +
+	"\amessage\x18\x01 \x01(\tR\amessage\x12\x1b\n" +
+	"\tparent_id\x18\x02 \x01(\tR\bparentId\"\x9e\x01\n" +
 	"\fChatResponse\x12\x14\n" +
 	"\x05reply\x18\x01 \x01(\tR\x05reply\x12\x14\n" +
 	"\x05agent\x18\x02 \x01(\tR\x05agent\x12.\n" +
 	"\n" +
-	"tool_calls\x18\x03 \x03(\v2\x0f.agent.ToolCallR\ttoolCalls\"\\\n" +
+	"tool_calls\x18\x03 \x03(\v2\x0f.agent.ToolCallR\ttoolCalls\x12\x15\n" +
+	"\x06run_id\x18\x04 \x01(\tR\x05runId\x12\x1b\n" +
+	"\tparent_id\x18\x05 \x01(\tR\bparentId\"\\\n" +
 	"\bToolCall\x12\x0e\n" +
 	"\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" +
 	"\x04name\x18\x02 \x01(\tR\x04name\x12\x14\n" +
@@ -214,24 +244,24 @@ const file_proto_agent_proto_rawDesc = "" +
 	"\x04Chat\x12\x12.agent.ChatRequest\x1a\x13.agent.ChatResponse\"\x00B\x0fZ\r./proto;agentb\x06proto3"

 var (
-	file_proto_agent_proto_rawDescOnce sync.Once
-	file_proto_agent_proto_rawDescData []byte
+	file_agent_proto_agent_proto_rawDescOnce sync.Once
+	file_agent_proto_agent_proto_rawDescData []byte
 )

-func file_proto_agent_proto_rawDescGZIP() []byte {
-	file_proto_agent_proto_rawDescOnce.Do(func() {
-		file_proto_agent_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_proto_agent_proto_rawDesc), len(file_proto_agent_proto_rawDesc)))
+func file_agent_proto_agent_proto_rawDescGZIP() []byte {
+	file_agent_proto_agent_proto_rawDescOnce.Do(func() {
+		file_agent_proto_agent_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_agent_proto_agent_proto_rawDesc), len(file_agent_proto_agent_proto_rawDesc)))
 	})
-	return file_proto_agent_proto_rawDescData
+	return file_agent_proto_agent_proto_rawDescData
 }

-var file_proto_agent_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
-var file_proto_agent_proto_goTypes = []any{
+var file_agent_proto_agent_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_agent_proto_agent_proto_goTypes = []any{
 	(*ChatRequest)(nil),  // 0: agent.ChatRequest
 	(*ChatResponse)(nil), // 1: agent.ChatResponse
 	(*ToolCall)(nil),     // 2: agent.ToolCall
 }
-var file_proto_agent_proto_depIdxs = []int32{
+var file_agent_proto_agent_proto_depIdxs = []int32{
 	2, // 0: agent.ChatResponse.tool_calls:type_name -> agent.ToolCall
 	0, // 1: agent.Agent.Chat:input_type -> agent.ChatRequest
 	1, // 2: agent.Agent.Chat:output_type -> agent.ChatResponse
@@ -242,26 +272,26 @@ var file_proto_agent_proto_depIdxs = []int32{
 	0, // [0:1] is the sub-list for field type_name
 }

-func init() { file_proto_agent_proto_init() }
-func file_proto_agent_proto_init() {
-	if File_proto_agent_proto != nil {
+func init() { file_agent_proto_agent_proto_init() }
+func file_agent_proto_agent_proto_init() {
+	if File_agent_proto_agent_proto != nil {
 		return
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: unsafe.Slice(unsafe.StringData(file_proto_agent_proto_rawDesc), len(file_proto_agent_proto_rawDesc)),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_agent_proto_agent_proto_rawDesc), len(file_agent_proto_agent_proto_rawDesc)),
 			NumEnums:      0,
 			NumMessages:   3,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
-		GoTypes:           file_proto_agent_proto_goTypes,
-		DependencyIndexes: file_proto_agent_proto_depIdxs,
-		MessageInfos:      file_proto_agent_proto_msgTypes,
+		GoTypes:           file_agent_proto_agent_proto_goTypes,
+		DependencyIndexes: file_agent_proto_agent_proto_depIdxs,
+		MessageInfos:      file_agent_proto_agent_proto_msgTypes,
 	}.Build()
-	File_proto_agent_proto = out.File
-	file_proto_agent_proto_goTypes = nil
-	file_proto_agent_proto_depIdxs = nil
+	File_agent_proto_agent_proto = out.File
+	file_agent_proto_agent_proto_goTypes = nil
+	file_agent_proto_agent_proto_depIdxs = nil
 }
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-micro. DO NOT EDIT.
-// source: proto/agent.proto
+// source: agent/proto/agent.proto

 package agent

@@ -11,12 +11,20 @@ service Agent {

 message ChatRequest {
 	string message = 1;
+
+	// parent_id correlates this chat with the workflow or agent run that dispatched it.
+	string parent_id = 2;
 }

 message ChatResponse {
 	string reply = 1;
 	string agent = 2;
 	repeated ToolCall tool_calls = 3;
+
+	// run_id correlates this chat response with tool calls, traces, and run history.
+	string run_id = 4;
+	// parent_id is set when this response belongs to a delegated sub-agent run.
+	string parent_id = 5;
 }

 message ToolCall {
@@ -3,6 +3,7 @@ package agent
 import (
 	"context"
 	"errors"
+	"strings"
 	"testing"
 	"time"

@@ -75,3 +76,29 @@ func TestAskRetriesTransientErrorsThenSurfacesStructuredError(t *testing.T) {
 		t.Fatalf("model attempts = %d, want 2", attempts)
 	}
 }
+
+func TestCanceledAskContextSkipsToolExecution(t *testing.T) {
+	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
+		if opts.ToolHandler == nil {
+			t.Fatal("missing tool handler")
+		}
+		canceled, cancel := context.WithCancel(ctx)
+		cancel()
+		res := opts.ToolHandler(canceled, ai.ToolCall{ID: "call-1", Name: toolPlan, Input: map[string]any{
+			"steps": []any{map[string]any{"task": "should not persist", "status": "pending"}},
+		}})
+		if !strings.Contains(res.Content, context.Canceled.Error()) {
+			t.Fatalf("tool result = %q, want cancellation error", res.Content)
+		}
+		return &ai.Response{Reply: "ok"}, nil
+	}
+	defer func() { fakeGen = nil }()
+
+	a := newTestAgent(Name("cancel-tools"))
+	if _, err := a.Ask(context.Background(), "try a canceled tool"); err != nil {
+		t.Fatalf("Ask: %v", err)
+	}
+	if plan := a.loadPlan(); plan != "" {
+		t.Fatalf("plan persisted after canceled tool context: %q", plan)
+	}
+}
@@ -188,6 +188,22 @@ type Response struct {
 - `ToolCalls`: List of tools the model requested (if any)
 - `Answer`: The final answer after tools are executed (only set if ToolHandler is provided)

+## Provider capability matrix
+
+The CLI can print the provider capabilities registered in the current build:
+
+```bash
+micro ai providers
+```
+
+For automation and docs generation, emit the same matrix as stable JSON:
+
+```bash
+micro ai providers --json
+```
+
+It reports support from Go Micro's provider registry, so the matrix reflects the model, image, and video interfaces available to this binary rather than external provider marketing claims.
+
 ## Supported Providers

 ### Anthropic Claude
@@ -2,16 +2,27 @@ package ai

 import "sort"

+// CapabilityRow is one deterministic row in a provider capability matrix.
+type CapabilityRow struct {
+	// Provider is the registered provider name.
+	Provider string `json:"provider"`
+	Capabilities
+}
+
 // Capabilities describes the AI interfaces a provider has registered.
 // It is intentionally based on package registration rather than external
 // provider marketing claims, so it reflects what this build can actually use.
 type Capabilities struct {
 	// Model reports whether ai.New can construct a chat/text model provider.
-	Model bool
+	Model bool `json:"model"`
 	// Image reports whether ai.NewImage can construct an image model provider.
-	Image bool
+	Image bool `json:"image"`
 	// Video reports whether ai.NewVideo can construct a video model provider.
-	Video bool
+	Video bool `json:"video"`
+	// Stream reports whether the provider has registered end-to-end token streaming.
+	// Providers that only satisfy the Model interface with ErrStreamingUnsupported
+	// leave this false until their Stream implementation is usable.
+	Stream bool `json:"stream"`
 }

 // ProviderCapabilities reports the capabilities registered for provider.
@@ -19,17 +30,20 @@ func ProviderCapabilities(provider string) Capabilities {
 	_, hasModel := providers[provider]
 	_, hasImage := imageProviders[provider]
 	_, hasVideo := videoProviders[provider]
+	_, hasStream := streamProviders[provider]

 	return Capabilities{
-		Model: hasModel,
-		Image: hasImage,
-		Video: hasVideo,
+		Model:  hasModel,
+		Image:  hasImage,
+		Video:  hasVideo,
+		Stream: hasStream,
 	}
 }

-// CapabilityMatrix returns a stable snapshot of all registered AI providers and
-// the interfaces they support. The returned map is a copy and can be modified by
-// callers without mutating the registry.
+// CapabilityMatrix returns a snapshot of all registered AI providers and the
+// interfaces they support. The returned map is a copy and can be modified by
+// callers without mutating the registry. Use CapabilityRows when rendering a
+// deterministic table or report.
 func CapabilityMatrix() map[string]Capabilities {
 	names := map[string]struct{}{}
 	for name := range providers {
@@ -41,6 +55,9 @@ func CapabilityMatrix() map[string]Capabilities {
 	for name := range videoProviders {
 		names[name] = struct{}{}
 	}
+	for name := range streamProviders {
+		names[name] = struct{}{}
+	}

 	matrix := make(map[string]Capabilities, len(names))
 	for name := range names {
@@ -49,8 +66,32 @@ func CapabilityMatrix() map[string]Capabilities {
 	return matrix
 }

+// CapabilityRows returns a deterministic capability support matrix for every
+// registered AI provider. It is the ordered form of CapabilityMatrix, intended
+// for CLIs, docs generators, and conformance reports that need stable output.
+func CapabilityRows() []CapabilityRow {
+	names := RegisteredProviders("")
+	rows := make([]CapabilityRow, 0, len(names))
+	for _, name := range names {
+		rows = append(rows, CapabilityRow{
+			Provider:     name,
+			Capabilities: ProviderCapabilities(name),
+		})
+	}
+	return rows
+}
+
+// RegisterStream records that provider has a usable Stream implementation.
+// Providers should call this from init alongside Register once Stream returns
+// chunks instead of ErrStreamingUnsupported.
+func RegisterStream(provider string) {
+	streamProviders[provider] = struct{}{}
+}
+
+var streamProviders = make(map[string]struct{})
+
 // RegisteredProviders returns the registered provider names in sorted order.
-// kind may be "model", "image", "video", or empty for the union of all
+// kind may be "model", "image", "video", "stream", or empty for the union of all
 // provider registries.
 func RegisteredProviders(kind string) []string {
 	names := map[string]struct{}{}
@@ -68,12 +109,18 @@ func RegisteredProviders(kind string) []string {
 			for name := range r {
 				names[name] = struct{}{}
 			}
+		case map[string]struct{}:
+			for name := range r {
+				names[name] = struct{}{}
+			}
 		}
 	}

 	switch kind {
 	case "model":
 		add(providers)
+	case "stream":
+		add(streamProviders)
 	case "image":
 		add(imageProviders)
 	case "video":
@@ -32,6 +32,28 @@ func TestRegisteredProviders(t *testing.T) {
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("RegisteredProviders(video) = %#v, want %#v", got, want)
 	}
+
+	got = ai.RegisteredProviders("stream")
+	want = []string{}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("RegisteredProviders(stream) = %#v, want %#v", got, want)
+	}
+}
+
+func TestCapabilityRows(t *testing.T) {
+	got := ai.CapabilityRows()
+	want := []ai.CapabilityRow{
+		{Provider: "anthropic", Capabilities: ai.Capabilities{Model: true}},
+		{Provider: "atlascloud", Capabilities: ai.Capabilities{Model: true, Image: true, Video: true}},
+		{Provider: "gemini", Capabilities: ai.Capabilities{Model: true}},
+		{Provider: "groq", Capabilities: ai.Capabilities{Model: true}},
+		{Provider: "mistral", Capabilities: ai.Capabilities{Model: true}},
+		{Provider: "openai", Capabilities: ai.Capabilities{Model: true, Image: true}},
+		{Provider: "together", Capabilities: ai.Capabilities{Model: true}},
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("CapabilityRows() = %#v, want %#v", got, want)
+	}
 }

 func TestCapabilityMatrix(t *testing.T) {
@@ -57,3 +79,17 @@ func TestCapabilityMatrix(t *testing.T) {
 		t.Fatalf("ProviderCapabilities(missing) = %#v", caps)
 	}
 }
+
+func TestRegisterStream(t *testing.T) {
+	ai.RegisterStream("test-stream")
+
+	if caps := ai.ProviderCapabilities("test-stream"); caps != (ai.Capabilities{Stream: true}) {
+		t.Fatalf("ProviderCapabilities(test-stream) = %#v", caps)
+	}
+
+	got := ai.RegisteredProviders("stream")
+	want := []string{"test-stream"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("RegisteredProviders(stream) = %#v, want %#v", got, want)
+	}
+}
@@ -0,0 +1,96 @@
+package ai
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+)
+
+type retryModel struct {
+	generate func(context.Context, *Request, ...GenerateOption) (*Response, error)
+}
+
+func (m retryModel) Init(...Option) error { return nil }
+func (m retryModel) Options() Options     { return Options{} }
+func (m retryModel) Generate(ctx context.Context, req *Request, opts ...GenerateOption) (*Response, error) {
+	return m.generate(ctx, req, opts...)
+}
+func (m retryModel) Stream(context.Context, *Request, ...GenerateOption) (Stream, error) {
+	return nil, ErrStreamingUnsupported
+}
+func (m retryModel) String() string { return "retry-test" }
+
+func TestGenerateWithRetryRetriesTransientErrors(t *testing.T) {
+	attempts := 0
+	model := retryModel{generate: func(context.Context, *Request, ...GenerateOption) (*Response, error) {
+		attempts++
+		if attempts == 1 {
+			return nil, errors.New("temporary provider outage")
+		}
+		return &Response{Reply: "ok"}, nil
+	}}
+
+	resp, err := GenerateWithRetry(context.Background(), model, &Request{Prompt: "hi"}, GeneratePolicy{
+		MaxAttempts: 2,
+		Backoff:     time.Millisecond,
+	})
+	if err != nil {
+		t.Fatalf("GenerateWithRetry returned error: %v", err)
+	}
+	if resp.Reply != "ok" {
+		t.Fatalf("response reply = %q, want ok", resp.Reply)
+	}
+	if attempts != 2 {
+		t.Fatalf("attempts = %d, want 2", attempts)
+	}
+}
+
+func TestGenerateWithRetryDoesNotRetryCallerCancellation(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	attempts := 0
+	model := retryModel{generate: func(context.Context, *Request, ...GenerateOption) (*Response, error) {
+		attempts++
+		cancel()
+		return nil, errors.New("temporary provider outage")
+	}}
+
+	_, err := GenerateWithRetry(ctx, model, &Request{Prompt: "hi"}, GeneratePolicy{
+		MaxAttempts: 3,
+		Backoff:     time.Millisecond,
+	})
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("error = %v, want context.Canceled", err)
+	}
+	if attempts != 1 {
+		t.Fatalf("attempts = %d, want 1", attempts)
+	}
+}
+
+func TestGenerateWithRetryHonorsPerAttemptTimeout(t *testing.T) {
+	attempts := 0
+	model := retryModel{generate: func(ctx context.Context, _ *Request, _ ...GenerateOption) (*Response, error) {
+		attempts++
+		<-ctx.Done()
+		return nil, ctx.Err()
+	}}
+
+	_, err := GenerateWithRetry(context.Background(), model, &Request{Prompt: "hi"}, GeneratePolicy{
+		Timeout:     time.Millisecond,
+		MaxAttempts: 2,
+		Backoff:     time.Millisecond,
+	})
+	var retryErr *RetryError
+	if !errors.As(err, &retryErr) {
+		t.Fatalf("error = %T %[1]v, want RetryError", err)
+	}
+	if retryErr.Attempts != 2 {
+		t.Fatalf("retry attempts = %d, want 2", retryErr.Attempts)
+	}
+	if !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("error = %v, want context.DeadlineExceeded", err)
+	}
+	if attempts != 2 {
+		t.Fatalf("attempts = %d, want 2", attempts)
+	}
+}
@@ -0,0 +1,72 @@
+package ai
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"github.com/urfave/cli/v2"
+	goai "go-micro.dev/v6/ai"
+	_ "go-micro.dev/v6/ai/anthropic"
+	_ "go-micro.dev/v6/ai/atlascloud"
+	_ "go-micro.dev/v6/ai/gemini"
+	_ "go-micro.dev/v6/ai/groq"
+	_ "go-micro.dev/v6/ai/mistral"
+	_ "go-micro.dev/v6/ai/openai"
+	_ "go-micro.dev/v6/ai/together"
+	"go-micro.dev/v6/cmd"
+)
+
+func init() {
+	cmd.Register(&cli.Command{
+		Name:  "ai",
+		Usage: "Inspect AI provider support",
+		Subcommands: []*cli.Command{{
+			Name:  "providers",
+			Usage: "Print the registered AI provider capability matrix",
+			Flags: []cli.Flag{
+				&cli.BoolFlag{
+					Name:  "json",
+					Usage: "Print the capability matrix as JSON",
+				},
+			},
+			Action: providersAction,
+		}},
+	})
+}
+
+func providersAction(c *cli.Context) error {
+	rows := goai.CapabilityRows()
+	if c.Bool("json") {
+		return writeProviderJSON(c.App.Writer, rows)
+	}
+	writeProviderMatrix(c.App.Writer, rows)
+	return nil
+}
+
+func writeProviderJSON(w io.Writer, rows []goai.CapabilityRow) error {
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+	return enc.Encode(rows)
+}
+
+func writeProviderMatrix(w io.Writer, rows []goai.CapabilityRow) {
+	const check = "✓"
+	fmt.Fprintln(w, "Provider    Model  Image  Video")
+	fmt.Fprintln(w, "--------    -----  -----  -----")
+	for _, row := range rows {
+		fmt.Fprintf(w, "%-11s %-6s %-6s %-6s\n",
+			row.Provider,
+			mark(row.Model, check),
+			mark(row.Image, check),
+			mark(row.Video, check),
+		)
+	}
+}
+
+func mark(ok bool, value string) string {
+	if ok {
+		return value
+	}
+	return "-"
+}
@@ -0,0 +1,53 @@
+package ai
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	goai "go-micro.dev/v6/ai"
+)
+
+func TestWriteProviderMatrix(t *testing.T) {
+	rows := []goai.CapabilityRow{
+		{Provider: "atlascloud", Capabilities: goai.Capabilities{Model: true, Image: true, Video: true}},
+		{Provider: "openai", Capabilities: goai.Capabilities{Model: true, Image: true}},
+	}
+
+	var out bytes.Buffer
+	writeProviderMatrix(&out, rows)
+	got := out.String()
+
+	for _, want := range []string{
+		"Provider    Model  Image  Video",
+		"atlascloud  ✓      ✓      ✓",
+		"openai      ✓      ✓      -",
+	} {
+		if !strings.Contains(got, want) {
+			t.Fatalf("matrix output missing %q:\n%s", want, got)
+		}
+	}
+}
+
+func TestWriteProviderJSON(t *testing.T) {
+	rows := []goai.CapabilityRow{
+		{Provider: "openai", Capabilities: goai.Capabilities{Model: true, Image: true}},
+	}
+
+	var out bytes.Buffer
+	if err := writeProviderJSON(&out, rows); err != nil {
+		t.Fatalf("writeProviderJSON returned error: %v", err)
+	}
+
+	var got []goai.CapabilityRow
+	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
+		t.Fatalf("JSON output did not decode: %v\n%s", err, out.String())
+	}
+	if len(got) != 1 || got[0].Provider != "openai" || !got[0].Model || !got[0].Image || got[0].Video {
+		t.Fatalf("decoded JSON = %#v, want openai model+image", got)
+	}
+	if !strings.HasSuffix(out.String(), "\n") {
+		t.Fatalf("JSON output should end with newline: %q", out.String())
+	}
+}
@@ -135,12 +135,13 @@ func runFlags() []cli.Flag {
 	return []cli.Flag{
 		&cli.BoolFlag{Name: "json", Usage: "Print run data as JSON for automation"},
 		&cli.StringFlag{Name: "status", Usage: "Only show runs with this status (running, done, error, refused)"},
+		&cli.StringFlag{Name: "trace", Usage: "Only show runs whose trace id matches this full id or prefix"},
 		&cli.IntFlag{Name: "limit", Usage: "Show the most recently updated N runs"},
 	}
 }

 func runOptions(c *cli.Context) goagent.RunListOptions {
-	return goagent.RunListOptions{Status: c.String("status"), Limit: c.Int("limit")}
+	return goagent.RunListOptions{Status: c.String("status"), TraceID: c.String("trace"), Limit: c.Int("limit")}
 }

 func printRunIndex(name string, opts goagent.RunListOptions, asJSON bool) error {
@@ -9,6 +9,7 @@ import (
 	"io"
 	"os"
 	"os/signal"
+	"sort"
 	"syscall"

 	"github.com/urfave/cli/v2"
@@ -75,6 +76,10 @@ Examples:
 				ArgsUsage: "[name]",
 				Flags: []cli.Flag{
 					&cli.BoolFlag{Name: "json", Usage: "Print durable run history as JSON for automation"},
+					&cli.BoolFlag{Name: "pending", Usage: "Only show runs that have not completed"},
+					&cli.StringFlag{Name: "status", Usage: "Only show runs with this status (running, done, failed)"},
+					&cli.IntFlag{Name: "limit", Usage: "Show the most recently updated N runs"},
+					&cli.StringFlag{Name: "stage", Usage: "Only show runs currently checkpointed at this stage"},
 				},
 				Action: flowRuns,
 			},
@@ -129,19 +134,83 @@ func flowRuns(c *cli.Context) error {
 	if err != nil {
 		return err
 	}
+	opts, err := validateFlowRunOptions(flowRunOptions{Pending: c.Bool("pending"), Status: c.String("status"), Stage: c.String("stage"), Limit: c.Int("limit")})
+	if err != nil {
+		return err
+	}
+	runs = filterFlowRuns(runs, opts)
 	if len(runs) == 0 {
+		if c.Bool("pending") {
+			fmt.Printf("  No pending runs recorded for flow %q.\n", name)
+			return nil
+		}
 		fmt.Printf("  No runs recorded for flow %q.\n", name)
 		return nil
 	}
 	return writeFlowRuns(os.Stdout, runs, c.Bool("json"))
 }

+type flowRunOptions struct {
+	Pending bool
+	Status  string
+	Stage   string
+	Limit   int
+}
+
+func validateFlowRunOptions(opts flowRunOptions) (flowRunOptions, error) {
+	switch opts.Status {
+	case "", "running", "done", "failed":
+	default:
+		return opts, fmt.Errorf("invalid run status %q: expected running, done, or failed", opts.Status)
+	}
+	if opts.Limit < 0 {
+		return opts, fmt.Errorf("invalid limit %d: expected a non-negative value", opts.Limit)
+	}
+	return opts, nil
+}
+
+func filterFlowRuns(runs []aiflow.Run, opts flowRunOptions) []aiflow.Run {
+	if len(runs) == 0 {
+		return nil
+	}
+	filtered := make([]aiflow.Run, 0, len(runs))
+	for _, run := range runs {
+		if opts.Pending && run.Status == "done" {
+			continue
+		}
+		if opts.Status != "" && run.Status != opts.Status {
+			continue
+		}
+		if opts.Stage != "" && run.State.Stage != opts.Stage {
+			continue
+		}
+		filtered = append(filtered, run)
+	}
+	if opts.Limit > 0 && len(filtered) > opts.Limit {
+		sort.SliceStable(filtered, func(i, j int) bool {
+			if filtered[i].Updated.Equal(filtered[j].Updated) {
+				return filtered[i].Started.Before(filtered[j].Started)
+			}
+			return filtered[i].Updated.Before(filtered[j].Updated)
+		})
+		start := len(filtered) - opts.Limit
+		limited := append([]aiflow.Run(nil), filtered[start:]...)
+		return limited
+	}
+	return filtered
+}
+
+func pendingFlowRuns(runs []aiflow.Run) []aiflow.Run {
+	return filterFlowRuns(runs, flowRunOptions{Pending: true})
+}
+
 func writeFlowRuns(w io.Writer, runs []aiflow.Run, asJSON bool) error {
 	if asJSON {
 		enc := json.NewEncoder(w)
 		enc.SetIndent("", "  ")
 		return enc.Encode(runs)
 	}
+	fmt.Fprintf(w, "  %d run%s\n", len(runs), plural(len(runs)))
 	for _, r := range runs {
 		id := r.ID
 		if len(id) > 8 {
@@ -164,6 +233,13 @@ func writeFlowRuns(w io.Writer, runs []aiflow.Run, asJSON bool) error {
 	return nil
 }

+func plural(n int) string {
+	if n == 1 {
+		return ""
+	}
+	return "s"
+}
+
 func flowFlags() []cli.Flag {
 	return []cli.Flag{
 		&cli.StringFlag{Name: "trigger", Usage: "Broker topic to subscribe to", EnvVars: []string{"MICRO_FLOW_TRIGGER"}},
@@ -29,6 +29,7 @@ func TestWriteFlowRunsIncludesStepDetails(t *testing.T) {
 	}
 	got := out.String()
 	for _, want := range []string{
+		"1 run",
 		"12345678  failed   stage=charge",
 		"updated=2026-06-24T12:30:00Z",
 		"- reserve      done        attempts=1",
@@ -40,6 +41,20 @@ func TestWriteFlowRunsIncludesStepDetails(t *testing.T) {
 	}
 }

+func TestValidateFlowRunOptionsRejectsInvalidStatus(t *testing.T) {
+	_, err := validateFlowRunOptions(flowRunOptions{Status: "stuck"})
+	if err == nil || !strings.Contains(err.Error(), "invalid run status") {
+		t.Fatalf("expected invalid status error, got %v", err)
+	}
+}
+
+func TestValidateFlowRunOptionsRejectsNegativeLimit(t *testing.T) {
+	_, err := validateFlowRunOptions(flowRunOptions{Limit: -1})
+	if err == nil || !strings.Contains(err.Error(), "invalid limit") {
+		t.Fatalf("expected invalid limit error, got %v", err)
+	}
+}
+
 func TestWriteFlowRunsJSON(t *testing.T) {
 	runs := []aiflow.Run{{ID: "run-1", Flow: "checkout", Status: "done"}}

@@ -55,3 +70,87 @@ func TestWriteFlowRunsJSON(t *testing.T) {
 		t.Fatalf("decoded runs = %+v", got)
 	}
 }
+
+func TestPendingFlowRunsFiltersCompletedRuns(t *testing.T) {
+	runs := []aiflow.Run{
+		{ID: "run-1", Status: "done"},
+		{ID: "run-2", Status: "failed"},
+		{ID: "run-3", Status: "running"},
+	}
+
+	got := pendingFlowRuns(runs)
+	if len(got) != 2 {
+		t.Fatalf("pendingFlowRuns returned %d runs, want 2: %+v", len(got), got)
+	}
+	if got[0].ID != "run-2" || got[1].ID != "run-3" {
+		t.Fatalf("pending runs = %+v", got)
+	}
+}
+
+func TestFilterFlowRunsStatus(t *testing.T) {
+	runs := []aiflow.Run{
+		{ID: "run-1", Status: "done"},
+		{ID: "run-2", Status: "failed"},
+		{ID: "run-3", Status: "running"},
+		{ID: "run-4", Status: "failed"},
+	}
+
+	got := filterFlowRuns(runs, flowRunOptions{Status: "failed"})
+	if len(got) != 2 {
+		t.Fatalf("filterFlowRuns returned %d runs, want 2: %+v", len(got), got)
+	}
+	if got[0].ID != "run-2" || got[1].ID != "run-4" {
+		t.Fatalf("failed runs = %+v", got)
+	}
+}
+
+func TestFilterFlowRunsStage(t *testing.T) {
+	runs := []aiflow.Run{
+		{ID: "run-1", Status: "failed", State: aiflow.State{Stage: "reserve"}},
+		{ID: "run-2", Status: "failed", State: aiflow.State{Stage: "charge"}},
+		{ID: "run-3", Status: "running", State: aiflow.State{Stage: "charge"}},
+		{ID: "run-4", Status: "done", State: aiflow.State{}},
+	}
+
+	got := filterFlowRuns(runs, flowRunOptions{Stage: "charge"})
+	if len(got) != 2 {
+		t.Fatalf("filterFlowRuns returned %d runs, want 2: %+v", len(got), got)
+	}
+	if got[0].ID != "run-2" || got[1].ID != "run-3" {
+		t.Fatalf("charge-stage runs = %+v", got)
+	}
+}
+
+func TestFilterFlowRunsLimitKeepsNewestRuns(t *testing.T) {
+	runs := []aiflow.Run{
+		{ID: "run-1", Status: "done"},
+		{ID: "run-2", Status: "failed"},
+		{ID: "run-3", Status: "running"},
+	}
+
+	got := filterFlowRuns(runs, flowRunOptions{Limit: 2})
+	if len(got) != 2 {
+		t.Fatalf("filterFlowRuns returned %d runs, want 2: %+v", len(got), got)
+	}
+	if got[0].ID != "run-2" || got[1].ID != "run-3" {
+		t.Fatalf("limited runs = %+v", got)
+	}
+}
+
+func TestFilterFlowRunsCombinesPendingStatusAndLimit(t *testing.T) {
+	runs := []aiflow.Run{
+		{ID: "run-1", Status: "failed"},
+		{ID: "run-2", Status: "done"},
+		{ID: "run-3", Status: "failed"},
+		{ID: "run-4", Status: "running"},
+		{ID: "run-5", Status: "failed"},
+	}
+
+	got := filterFlowRuns(runs, flowRunOptions{Pending: true, Status: "failed", Limit: 2})
+	if len(got) != 2 {
+		t.Fatalf("filterFlowRuns returned %d runs, want 2: %+v", len(got), got)
+	}
+	if got[0].ID != "run-3" || got[1].ID != "run-5" {
+		t.Fatalf("filtered runs = %+v", got)
+	}
+}
@@ -5,6 +5,7 @@ import (
 	"go-micro.dev/v6/cmd"

 	_ "go-micro.dev/v6/cmd/micro/a2a"
+	_ "go-micro.dev/v6/cmd/micro/ai"
 	_ "go-micro.dev/v6/cmd/micro/api"
 	_ "go-micro.dev/v6/cmd/micro/chat"
 	_ "go-micro.dev/v6/cmd/micro/cli"
@@ -2,6 +2,7 @@ package flow

 import (
 	"context"
+	"encoding/json"
 	"testing"

 	"go-micro.dev/v6/client"
@@ -25,11 +26,17 @@ func (c *fakeClient) Call(ctx context.Context, req client.Request, rsp interface
 func TestExecuteDispatchesToAgent(t *testing.T) {
 	f := New("welcome", Agent("comms"), Prompt("welcome {{.Data}}"))

-	var svc, ep string
+	var svc, ep, parentID string
 	f.client = &fakeClient{
 		Client: client.DefaultClient,
 		callFn: func(req client.Request, rsp interface{}) error {
 			svc, ep = req.Service(), req.Endpoint()
+			reqFrame := req.Body().(*codecbytes.Frame)
+			var body map[string]string
+			if err := json.Unmarshal(reqFrame.Data, &body); err != nil {
+				t.Fatalf("request body: %v", err)
+			}
+			parentID = body["parent_id"]
 			frame := rsp.(*codecbytes.Frame)
 			frame.Data = []byte(`{"reply":"welcomed bob","agent":"comms"}`)
 			return nil
@@ -43,6 +50,9 @@ func TestExecuteDispatchesToAgent(t *testing.T) {
 	if svc != "comms" || ep != "Agent.Chat" {
 		t.Errorf("dispatched to %s.%s, want comms.Agent.Chat", svc, ep)
 	}
+	if parentID == "" {
+		t.Fatal("dispatch request parent_id is empty")
+	}

 	results := f.Results()
 	if len(results) != 1 {
@@ -205,6 +205,9 @@ func (f *Flow) Execute(ctx context.Context, data string) error {
 		return err
 	}

+	runID := uuid.New().String()
+	ctx = ai.WithRunInfo(ctx, ai.RunInfo{RunID: runID, Agent: f.name})
+
 	start := time.Now()

 	prompt := data
@@ -277,7 +280,8 @@ func (f *Flow) Execute(ctx context.Context, data string) error {
 // callAgent hands the rendered prompt to a registered agent's Agent.Chat
 // endpoint over RPC and returns its reply.
 func (f *Flow) callAgent(ctx context.Context, name, message string) (string, error) {
-	body, _ := json.Marshal(map[string]string{"message": message})
+	info, _ := ai.RunInfoFrom(ctx)
+	body, _ := json.Marshal(map[string]string{"message": message, "parent_id": info.RunID})
 	req := f.client.NewRequest(name, "Agent.Chat", &codecbytes.Frame{Data: body})
 	var rsp codecbytes.Frame
 	if err := f.client.Call(ctx, req, &rsp); err != nil {
@@ -1,6 +1,10 @@
 package flow

-import "time"
+import (
+	"time"
+
+	"go.opentelemetry.io/otel/trace"
+)

 // Options configures a Flow.
 type Options struct {
@@ -40,6 +44,8 @@ type Options struct {
 	// Checkpoint is the durability backend for stepped runs. Nil with
 	// steps present means a store-backed default; set it to swap backends.
 	Checkpoint Checkpoint
+	// TraceProvider emits OpenTelemetry spans for stepped flow runs.
+	TraceProvider trace.TracerProvider
 	// DeleteOnSuccess removes a run's checkpoint when it completes
 	// successfully. Failed runs are always retained. Default: retain all.
 	DeleteOnSuccess bool
@@ -132,3 +138,8 @@ func WithCheckpoint(c Checkpoint) Option {
 func DeleteOnSuccess() Option {
 	return func(o *Options) { o.DeleteOnSuccess = true }
 }
+
+// TraceProvider enables OpenTelemetry spans for stepped flow runs and steps.
+func TraceProvider(tp trace.TracerProvider) Option {
+	return func(o *Options) { o.TraceProvider = tp }
+}
@@ -0,0 +1,80 @@
+package flow
+
+import (
+	"context"
+	"time"
+
+	"go-micro.dev/v6/ai"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
+)
+
+const flowInstrumentationName = "go-micro.dev/v6/flow"
+
+const (
+	spanNameFlowRun  = "flow.run"
+	spanNameFlowStep = "flow.step"
+
+	AttrFlowRunID     = "flow.run.id"
+	AttrFlowName      = "flow.name"
+	AttrFlowStepName  = "flow.step.name"
+	AttrFlowStatus    = "flow.status"
+	AttrFlowAttempts  = "flow.step.attempts"
+	AttrFlowLatencyMS = "flow.latency_ms"
+)
+
+func (f *Flow) tracer() trace.Tracer {
+	return f.opts.TraceProvider.Tracer(flowInstrumentationName)
+}
+
+func (f *Flow) startRunSpan(ctx context.Context, run Run) (context.Context, func(Run, error)) {
+	if f.opts.TraceProvider == nil {
+		return ctx, func(Run, error) {}
+	}
+	ctx, span := f.tracer().Start(ctx, spanNameFlowRun, trace.WithSpanKind(trace.SpanKindInternal), trace.WithAttributes(
+		attribute.String(AttrFlowRunID, run.ID),
+		attribute.String(AttrFlowName, f.name),
+		attribute.String(AttrFlowStatus, run.Status),
+	))
+	start := time.Now()
+	return ctx, func(done Run, err error) {
+		span.SetAttributes(
+			attribute.String(AttrFlowStatus, done.Status),
+			attribute.Int64(AttrFlowLatencyMS, time.Since(start).Milliseconds()),
+		)
+		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, err.Error())
+		} else {
+			span.SetStatus(codes.Ok, "")
+		}
+		span.End()
+	}
+}
+
+func (f *Flow) runStepSpan(ctx context.Context, step Step, in State) (State, int, error) {
+	if f.opts.TraceProvider == nil {
+		return f.runStep(ctx, step, in)
+	}
+	info, _ := ai.RunInfoFrom(ctx)
+	ctx, span := f.tracer().Start(ctx, spanNameFlowStep, trace.WithAttributes(
+		attribute.String(AttrFlowRunID, info.RunID),
+		attribute.String(AttrFlowName, f.name),
+		attribute.String(AttrFlowStepName, step.Name),
+	))
+	start := time.Now()
+	out, attempts, err := f.runStep(ctx, step, in)
+	span.SetAttributes(
+		attribute.Int(AttrFlowAttempts, attempts),
+		attribute.Int64(AttrFlowLatencyMS, time.Since(start).Milliseconds()),
+	)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+	} else {
+		span.SetStatus(codes.Ok, "")
+	}
+	span.End()
+	return out, attempts, err
+}
@@ -0,0 +1,70 @@
+package flow
+
+import (
+	"context"
+	"testing"
+
+	"go-micro.dev/v6/store"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/sdk/trace"
+	"go.opentelemetry.io/otel/sdk/trace/tracetest"
+)
+
+func TestFlowOpenTelemetrySpans(t *testing.T) {
+	exp := tracetest.NewInMemoryExporter()
+	tp := trace.NewTracerProvider(trace.WithSyncer(exp))
+
+	step := Step{Name: "inspect", Run: func(ctx context.Context, in State) (State, error) {
+		in.Data = []byte("done")
+		return in, nil
+	}}
+	f := New("observed", WithCheckpoint(StoreCheckpoint(store.NewMemoryStore(), "observed")), TraceProvider(tp), Steps(step))
+	if err := f.Execute(context.Background(), "start"); err != nil {
+		t.Fatal(err)
+	}
+
+	spans := exp.GetSpans().Snapshots()
+	seen := map[string]bool{spanNameFlowRun: false, spanNameFlowStep: false}
+	var runID string
+	for _, span := range spans {
+		attrs := flowSpanAttributes(span.Attributes())
+		switch span.Name() {
+		case spanNameFlowRun:
+			seen[spanNameFlowRun] = true
+			runID = attrs[AttrFlowRunID]
+			if attrs[AttrFlowName] != "observed" || attrs[AttrFlowStatus] != "done" {
+				t.Fatalf("run span attributes = %#v", attrs)
+			}
+		case spanNameFlowStep:
+			seen[spanNameFlowStep] = true
+			if attrs[AttrFlowName] != "observed" || attrs[AttrFlowStepName] != "inspect" {
+				t.Fatalf("step span attributes = %#v", attrs)
+			}
+		}
+	}
+	for name, ok := range seen {
+		if !ok {
+			t.Fatalf("span %s not emitted; got %d spans", name, len(spans))
+		}
+	}
+	if runID == "" {
+		t.Fatal("run span missing run id")
+	}
+	for _, span := range spans {
+		if span.Name() != spanNameFlowStep {
+			continue
+		}
+		attrs := flowSpanAttributes(span.Attributes())
+		if attrs[AttrFlowRunID] != runID {
+			t.Fatalf("step span run id = %q, want %q", attrs[AttrFlowRunID], runID)
+		}
+	}
+}
+
+func flowSpanAttributes(attrs []attribute.KeyValue) map[string]string {
+	out := make(map[string]string, len(attrs))
+	for _, attr := range attrs {
+		out[string(attr.Key)] = attr.Value.AsString()
+	}
+	return out
+}
@@ -240,7 +240,8 @@ func Dispatch(name string) StepFunc {
 		if d := depsFrom(ctx); d != nil && d.client != nil {
 			cl = d.client
 		}
-		body, _ := json.Marshal(map[string]string{"message": in.String()})
+		info, _ := ai.RunInfoFrom(ctx)
+		body, _ := json.Marshal(map[string]string{"message": in.String(), "parent_id": info.RunID})
 		req := cl.NewRequest(name, "Agent.Chat", &codecbytes.Frame{Data: body})
 		var rsp codecbytes.Frame
 		if err := cl.Call(ctx, req, &rsp); err != nil {
@@ -305,6 +306,9 @@ func LLM(prompt string) StepFunc {

 // startRun begins a fresh run of the flow's steps with the given input.
 func (f *Flow) startRun(ctx context.Context, data string) (Run, error) {
+	if err := validateSteps(f.opts.Steps); err != nil {
+		return Run{}, err
+	}
 	run := Run{
 		ID:      uuid.New().String(),
 		Flow:    f.name,
@@ -321,6 +325,9 @@ func (f *Flow) startRun(ctx context.Context, data string) (Run, error) {
 // Resume continues a persisted run by id, picking up at the step it
 // stopped on. Completed runs are a no-op.
 func (f *Flow) Resume(ctx context.Context, runID string) error {
+	if err := validateSteps(f.opts.Steps); err != nil {
+		return err
+	}
 	if f.checkpoint == nil {
 		return fmt.Errorf("flow %s has no checkpoint configured", f.name)
 	}
@@ -383,6 +390,10 @@ func (f *Flow) Pending(ctx context.Context) ([]Run, error) {
 func (f *Flow) runFrom(ctx context.Context, run Run) (Run, error) {
 	steps := f.opts.Steps
 	ctx = withDeps(ctx, &runDeps{client: f.client, model: f.model, tools: f.toolSet})
+	ctx = ai.WithRunInfo(ctx, ai.RunInfo{RunID: run.ID, Agent: f.name})
+	ctx, finishSpan := f.startRunSpan(ctx, run)
+	var spanErr error
+	defer func() { finishSpan(run, spanErr) }()

 	start := stepIndex(steps, run.State.Stage)
 	if start < 0 {
@@ -397,15 +408,22 @@ func (f *Flow) runFrom(ctx context.Context, run Run) (Run, error) {
 		step := steps[i]
 		run.State.Stage = step.Name
 		run.Steps[i].Status = "in_progress"
-		f.save(ctx, run)
+		if err := f.save(ctx, run); err != nil {
+			spanErr = err
+			return run, err
+		}

-		out, attempts, err := f.runStep(ctx, step, run.State)
+		out, attempts, err := f.runStepSpan(ctx, step, run.State)
 		run.Steps[i].Attempts = attempts
 		if err != nil {
+			spanErr = err
 			run.Steps[i].Status = "failed"
 			run.Steps[i].Error = err.Error()
 			run.Status = "failed"
-			f.save(ctx, run)
+			if saveErr := f.save(ctx, run); saveErr != nil {
+				spanErr = saveErr
+				return run, fmt.Errorf("%w; additionally failed to checkpoint failed run: %v", err, saveErr)
+			}
 			f.record(resultFromRun(f.opts.TriggerTopic, run))
 			f.log.Logf(logger.ErrorLevel, "Flow %s run %s failed at step %q: %v", f.name, run.ID, step.Name, err)
 			return run, err
@@ -419,13 +437,22 @@ func (f *Flow) runFrom(ctx context.Context, run Run) (Run, error) {
 		} else {
 			run.State.Stage = ""
 		}
-		f.save(ctx, run)
+		if err := f.save(ctx, run); err != nil {
+			spanErr = err
+			return run, err
+		}
 	}

 	run.Status = "done"
-	f.save(ctx, run)
+	if err := f.save(ctx, run); err != nil {
+		spanErr = err
+		return run, err
+	}
 	if f.opts.DeleteOnSuccess && f.checkpoint != nil {
-		_ = f.checkpoint.Delete(ctx, run.ID)
+		if err := f.checkpoint.Delete(ctx, run.ID); err != nil {
+			spanErr = err
+			return run, err
+		}
 	}
 	f.record(resultFromRun(f.opts.TriggerTopic, run))
 	f.log.Logf(logger.InfoLevel, "Flow %s run %s completed (%d steps)", f.name, run.ID, len(steps))
@@ -467,13 +494,29 @@ func (f *Flow) runStep(ctx context.Context, step Step, in State) (State, int, er
 	return in, retries + 1, lastErr
 }

-func (f *Flow) save(ctx context.Context, run Run) {
+func (f *Flow) save(ctx context.Context, run Run) error {
 	if f.checkpoint == nil {
-		return
+		return nil
 	}
 	if err := f.checkpoint.Save(ctx, run); err != nil {
 		f.log.Logf(logger.ErrorLevel, "Flow %s checkpoint save: %v", f.name, err)
+		return fmt.Errorf("flow %s checkpoint save: %w", f.name, err)
 	}
+	return nil
+}
+
+func validateSteps(steps []Step) error {
+	seen := make(map[string]struct{}, len(steps))
+	for i, step := range steps {
+		if step.Name == "" {
+			return fmt.Errorf("flow: step %d has an empty name", i)
+		}
+		if _, ok := seen[step.Name]; ok {
+			return fmt.Errorf("flow: duplicate step name %q", step.Name)
+		}
+		seen[step.Name] = struct{}{}
+	}
+	return nil
 }

 func stepIndex(steps []Step, name string) int {
@@ -6,6 +6,7 @@ import (
 	"testing"
 	"time"

+	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/store"
 )

@@ -86,6 +87,33 @@ func TestFlowCheckpointResume(t *testing.T) {
 	}
 }

+func TestFlowStepContextIncludesRunInfo(t *testing.T) {
+	var got ai.RunInfo
+	step := Step{Name: "inspect", Run: func(ctx context.Context, in State) (State, error) {
+		var ok bool
+		got, ok = ai.RunInfoFrom(ctx)
+		if !ok {
+			t.Fatal("RunInfo missing from step context")
+		}
+		in.Data = []byte("ok")
+		return in, nil
+	}}
+
+	f := New("correlated",
+		WithCheckpoint(StoreCheckpoint(store.NewMemoryStore(), "correlated")),
+		Steps(step),
+	)
+	if err := f.Execute(context.Background(), "start"); err != nil {
+		t.Fatalf("Execute: %v", err)
+	}
+	if got.Agent != "correlated" {
+		t.Fatalf("RunInfo.Agent = %q, want correlated", got.Agent)
+	}
+	if got.RunID == "" {
+		t.Fatal("RunInfo.RunID is empty")
+	}
+}
+
 func TestFlowResumePendingResumesOldestRunsUntilFailure(t *testing.T) {
 	mem := store.NewMemoryStore()
 	ctx := context.Background()
@@ -290,6 +318,41 @@ func TestFlowStepRetryStopsOnCancel(t *testing.T) {
 	}
 }

+func TestFlowStepNamesMustBeUnique(t *testing.T) {
+	step := Step{Name: "work", Run: func(_ context.Context, in State) (State, error) {
+		return in, nil
+	}}
+	f := New("duplicate-steps",
+		WithCheckpoint(StoreCheckpoint(store.NewMemoryStore(), "duplicate-steps")),
+		Steps(step, step),
+	)
+
+	err := f.Execute(context.Background(), "")
+	if err == nil {
+		t.Fatal("expected duplicate step names to fail validation")
+	}
+	if got, want := err.Error(), `flow: duplicate step name "work"`; got != want {
+		t.Fatalf("error = %q, want %q", got, want)
+	}
+}
+
+func TestFlowStepNamesMustBeNonEmpty(t *testing.T) {
+	f := New("empty-step-name",
+		WithCheckpoint(StoreCheckpoint(store.NewMemoryStore(), "empty-step-name")),
+		Steps(Step{Name: "", Run: func(_ context.Context, in State) (State, error) {
+			return in, nil
+		}}),
+	)
+
+	err := f.Execute(context.Background(), "")
+	if err == nil {
+		t.Fatal("expected an empty step name to fail validation")
+	}
+	if got, want := err.Error(), "flow: step 0 has an empty name"; got != want {
+		t.Fatalf("error = %q, want %q", got, want)
+	}
+}
+
 // A step with no Run function is reported as a configuration error rather
 // than panicking the run.
 func TestFlowStepNilRun(t *testing.T) {
@@ -354,6 +417,59 @@ func TestStoreCheckpointHonorsCanceledContext(t *testing.T) {
 	}
 }

+type failingCheckpoint struct {
+	err error
+}
+
+func (c failingCheckpoint) Save(context.Context, Run) error { return c.err }
+func (c failingCheckpoint) Load(context.Context, string) (Run, bool, error) {
+	return Run{}, false, c.err
+}
+func (c failingCheckpoint) Delete(context.Context, string) error { return c.err }
+func (c failingCheckpoint) List(context.Context) ([]Run, error)  { return nil, c.err }
+
+func TestFlowCheckpointSaveFailureStopsRun(t *testing.T) {
+	checkpointErr := errors.New("checkpoint unavailable")
+	var ran bool
+	f := New("checkpoint-fails",
+		WithCheckpoint(failingCheckpoint{err: checkpointErr}),
+		Steps(Step{Name: "work", Run: func(_ context.Context, in State) (State, error) {
+			ran = true
+			return in, nil
+		}}),
+	)
+
+	err := f.Execute(context.Background(), "start")
+	if !errors.Is(err, checkpointErr) {
+		t.Fatalf("Execute error = %v, want checkpoint error", err)
+	}
+	if ran {
+		t.Fatal("step ran even though the in-progress checkpoint failed")
+	}
+}
+
+func TestFlowDeleteOnSuccessFailureIsReturned(t *testing.T) {
+	checkpointErr := errors.New("delete unavailable")
+	cp := &deleteFailCheckpoint{Checkpoint: StoreCheckpoint(store.NewMemoryStore(), "delete-fails"), err: checkpointErr}
+	f := New("delete-fails",
+		WithCheckpoint(cp),
+		DeleteOnSuccess(),
+		Steps(appendStep("work")),
+	)
+
+	err := f.Execute(context.Background(), "")
+	if !errors.Is(err, checkpointErr) {
+		t.Fatalf("Execute error = %v, want delete error", err)
+	}
+}
+
+type deleteFailCheckpoint struct {
+	Checkpoint
+	err error
+}
+
+func (c *deleteFailCheckpoint) Delete(context.Context, string) error { return c.err }
+
 func TestStateSetScan(t *testing.T) {
 	var s State
 	type payload struct {
@@ -121,6 +121,29 @@ merged PRs. Each scheduled run:
  actually appears). Re-doing it creates duplicate PRs and stale branches that
  then block the next run. Wait for the PR, or let it ride.

+## Overseer passes (DevRel + Architect)
+
+The hourly loop ships increments; two periodic passes keep the *whole* heading in
+the right direction. Both use the same mechanism (fresh issue → `@codex` →
+output) but produce direction and coherence, not just code.
+
+- **DevRel — daily** (`.github/workflows/devrel-review.yml`). Audits the public
+  surface (README, website landing + docs, blog) for coherence with the North
+  Star, README crispness, and blog-worthy material. **Autonomy boundary:** safe
+  factual-alignment and crispness fixes auto-merge like any increment;
+  brand/positioning copy and blog drafts are *surfaced in a report* for the
+  human, never auto-merged.
+- **Architect — every few days** (`.github/workflows/architecture-review.yml`).
+  Reviews the framework/harness against the thesis: API coherence, lifecycle
+  gaps, drift/sprawl. **Its output is an assessment plus scoped follow-up
+  issues** that feed the hourly increment loop — it does **not** make breaking or
+  architectural changes itself (those stay with the human).
+
+Together they close the loop: the architect decides *what* should change and files
+issues, the increment loop *builds* them, and DevRel keeps the public story
+honest. Cadence is tunable in each workflow's `cron`. Codex is serial, so these
+passes queue behind any in-flight increment rather than running concurrently.
+
 ## Stop / redirect

 - In-session: `CronDelete <id>` (or end the session).
@@ -23,8 +23,15 @@ import (
 	"sync"
 	"time"

-	"go-micro.dev/v6"
+	"go-micro.dev/v6/agent"
 	"go-micro.dev/v6/ai"
+	"go-micro.dev/v6/broker"
+	"go-micro.dev/v6/client"
+	"go-micro.dev/v6/flow"
+	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/selector"
+	"go-micro.dev/v6/service"
+	"go-micro.dev/v6/store"
 )

 // ---------------------------------------------------------------------------
@@ -236,52 +243,95 @@ func main() {
 	fmt.Printf("\n\033[1mPlan & Delegate — live integration harness (provider: %s)\033[0m\n", *provider)
 	fmt.Print("Real services, registry, RPC, agent loop, store, delegation.\n\n")

+	reg := registry.NewMemoryRegistry()
+	cl := client.NewClient(client.Registry(reg), client.Selector(selector.NewSelector(selector.Registry(reg))))
+	mem := store.NewMemoryStore()
+
 	// Real services.
-	task := micro.NewService("task")
-	task.Handle(new(TaskService))
+	taskSvc := new(TaskService)
+	task := service.New(service.Name("task"), service.Address("127.0.0.1:0"), service.Registry(reg), service.Client(cl))
+	if err := task.Handle(taskSvc); err != nil {
+		fmt.Println("task handle:", err)
+		os.Exit(1)
+	}
 	go task.Run()

-	notify := micro.NewService("notify")
-	notify.Handle(new(NotifyService))
+	notifySvc := new(NotifyService)
+	notify := service.New(service.Name("notify"), service.Address("127.0.0.1:0"), service.Registry(reg), service.Client(cl))
+	if err := notify.Handle(notifySvc); err != nil {
+		fmt.Println("notify handle:", err)
+		os.Exit(1)
+	}
 	go notify.Run()

 	// Real comms agent (owns notify), registered so delegate reaches it over RPC.
-	comms := micro.NewAgent("comms",
-		micro.AgentServices("notify"),
-		micro.AgentPrompt("You handle outbound notifications. Use the notify service."),
-		micro.AgentProvider(*provider),
-		micro.AgentAPIKey(apiKey),
+	comms := agent.New(
+		agent.Name("comms"),
+		agent.Address("127.0.0.1:0"),
+		agent.Services("notify"),
+		agent.Prompt("You handle outbound notifications. Use the notify service."),
+		agent.Provider(*provider), agent.APIKey(apiKey),
+		agent.WithRegistry(reg), agent.WithClient(cl), agent.WithStore(mem),
 	)
 	go comms.Run()
+	defer comms.Stop()

-	// Real conductor agent (owns task).
-	conductor := micro.NewAgent("conductor",
-		micro.AgentServices("task"),
-		micro.AgentPrompt("You coordinate launch work. Plan first, create tasks, and delegate notifications to the \"comms\" agent."),
-		micro.AgentProvider(*provider),
-		micro.AgentAPIKey(apiKey),
+	// Real conductor agent (owns task), registered so the flow can reach it over RPC.
+	conductor := agent.New(
+		agent.Name("conductor"),
+		agent.Address("127.0.0.1:0"),
+		agent.Services("task"),
+		agent.Prompt("You coordinate launch work. Plan first, create tasks, and delegate notifications to the \"comms\" agent."),
+		agent.Provider(*provider), agent.APIKey(apiKey),
+		agent.WithRegistry(reg), agent.WithClient(cl), agent.WithStore(mem),
 	)
+	go conductor.Run()
+	defer conductor.Stop()

-	fmt.Println("waiting for services + comms agent to register...")
-	time.Sleep(3 * time.Second)
+	fmt.Println("waiting for services + agents to register...")
+	waitForService := func(name string) {
+		deadline := time.Now().Add(5 * time.Second)
+		for time.Now().Before(deadline) {
+			if svcs, err := reg.GetService(name); err == nil && len(svcs) > 0 && len(svcs[0].Nodes) > 0 {
+				return
+			}
+			time.Sleep(20 * time.Millisecond)
+		}
+	}
+	for _, name := range []string{"task", "notify", "comms", "conductor"} {
+		waitForService(name)
+	}

-	fmt.Print("\n\033[1m> prompt:\033[0m Create three launch tasks (Design, Build, Ship), then make sure owner@acme.com is notified.\n\n")
+	f := flow.New("zero-to-hero",
+		flow.Agent("conductor"),
+		flow.Prompt("Create three launch tasks (Design, Build, Ship), then make sure owner@acme.com is notified: {{.Data}}"),
+	)
+	if err := f.Register(reg, broker.DefaultBroker, cl); err != nil {
+		fmt.Println("flow register:", err)
+		os.Exit(1)
+	}

-	resp, err := conductor.Ask(context.Background(),
-		"Create three launch tasks: Design, Build, and Ship. Then make sure owner@acme.com is notified that the launch plan is ready.")
-	if err != nil {
+	fmt.Print("\n\033[1m> flow:\033[0m services + agents + workflow + plan/delegate, no API key.\n\n")
+	if err := f.Execute(context.Background(), "launch readiness"); err != nil {
 		fmt.Println("\033[31merror:\033[0m", err)
 		os.Exit(1)
 	}

-	fmt.Println("\n\033[1m< conductor reply:\033[0m", resp.Reply)
+	if rs := f.Results(); len(rs) > 0 {
+		fmt.Println("\n\033[1m< conductor reply:\033[0m", rs[len(rs)-1].Reply)
+	}

 	// Prove plan was persisted to the real store.
-	if recs, _ := conductor.Options().Store.Read("agent/conductor/plan"); len(recs) > 0 {
+	if recs, _ := store.Scope(mem, "agent", "conductor").Read("plan"); len(recs) > 0 {
 		fmt.Printf("\n\033[1mstored plan (agent/conductor/plan):\033[0m %s\n", string(recs[0].Value))
 	} else {
 		fmt.Println("\n\033[31m! plan was not persisted\033[0m")
+		os.Exit(1)
+	}
+	if taskSvc.count() != 3 || notifySvc.count() != 1 {
+		fmt.Printf("\n\033[31m! unexpected side effects: tasks=%d notify=%d\033[0m\n", taskSvc.count(), notifySvc.count())
+		os.Exit(1)
 	}

-	fmt.Println("\n\033[32m✓ end-to-end flow complete\033[0m")
+	fmt.Println("\n\033[32m✓ 0→hero flow complete (services → agents → workflow)\033[0m")
 }
@@ -14,6 +14,7 @@ package main

 import (
 	"context"
+	"encoding/json"
 	"flag"
 	"fmt"
 	"os"
@@ -22,6 +23,15 @@ import (
 	"slices"
 	"strings"
 	"time"
+
+	"go-micro.dev/v6/ai"
+	_ "go-micro.dev/v6/ai/anthropic"
+	_ "go-micro.dev/v6/ai/atlascloud"
+	_ "go-micro.dev/v6/ai/gemini"
+	_ "go-micro.dev/v6/ai/groq"
+	_ "go-micro.dev/v6/ai/mistral"
+	_ "go-micro.dev/v6/ai/openai"
+	_ "go-micro.dev/v6/ai/together"
 )

 var providerEnv = map[string]string{
@@ -39,6 +49,10 @@ func main() {
 	harnessesFlag := flag.String("harnesses", "universe,agent-flow,plan-delegate", "comma-separated harness names under internal/harness")
 	timeoutFlag := flag.Duration("timeout", 10*time.Minute, "timeout per provider/harness run")
 	requireConfiguredFlag := flag.Bool("require-configured", false, "fail when a selected live provider is missing an API key")
+	capabilitiesFlag := flag.Bool("capabilities", true, "print the registered provider capability matrix before running conformance")
+	summaryJSONFlag := flag.String("summary-json", "", "write a machine-readable conformance summary to this path")
+	summaryMarkdownFlag := flag.String("summary-markdown", "", "write a human-readable conformance summary to this path")
+	capabilityMarkdownFlag := flag.String("capabilities-markdown", "", "write the registered provider capability matrix as a Markdown table")
 	flag.Parse()

 	providers := splitCSV(*providersFlag)
@@ -48,16 +62,29 @@ func main() {
 		os.Exit(2)
 	}

+	if *capabilitiesFlag {
+		printCapabilityMatrix()
+	}
+	if *capabilityMarkdownFlag != "" {
+		if err := writeCapabilityMarkdown(*capabilityMarkdownFlag, ai.CapabilityRows()); err != nil {
+			fmt.Fprintf(os.Stderr, "write capabilities markdown: %v\n", err)
+			os.Exit(1)
+		}
+	}
+
 	var ran, skipped, failed int
+	var results []conformanceResult
 	for _, provider := range providers {
 		if provider != "mock" && providerKey(provider) == "" {
 			msg := fmt.Sprintf("set MICRO_AI_API_KEY or %s", providerEnv[provider])
 			if *requireConfiguredFlag {
 				fmt.Printf("FAIL %s: missing API key (%s)\n", provider, msg)
 				failed++
+				results = append(results, conformanceResult{Provider: provider, Status: statusFailed, Error: "missing API key: " + msg})
 			} else {
 				fmt.Printf("- %s: skipped (%s)\n", provider, msg)
 				skipped++
+				results = append(results, conformanceResult{Provider: provider, Status: statusSkipped, Error: msg})
 			}
 			continue
 		}
@@ -67,18 +94,138 @@ func main() {
 			if err := runHarness(provider, harness, *timeoutFlag); err != nil {
 				fmt.Printf("FAIL %s / %s: %v\n", provider, harness, err)
 				failed++
+				results = append(results, conformanceResult{Provider: provider, Harness: harness, Status: statusFailed, Error: err.Error()})
 				continue
 			}
 			ran++
+			results = append(results, conformanceResult{Provider: provider, Harness: harness, Status: statusPassed})
 		}
 	}

 	fmt.Printf("\nprovider conformance: %d passed, %d skipped providers, %d failed\n", ran, skipped, failed)
+	summary := conformanceSummary{
+		Providers:    providers,
+		Harnesses:    harnesses,
+		Capabilities: ai.CapabilityRows(),
+		Results:      results,
+		Passed:       ran,
+		Skipped:      skipped,
+		Failed:       failed,
+	}
+	if *summaryJSONFlag != "" {
+		if err := writeSummaryJSON(*summaryJSONFlag, summary); err != nil {
+			fmt.Fprintf(os.Stderr, "write summary: %v\n", err)
+			os.Exit(1)
+		}
+	}
+	if *summaryMarkdownFlag != "" {
+		if err := writeSummaryMarkdown(*summaryMarkdownFlag, summary); err != nil {
+			fmt.Fprintf(os.Stderr, "write summary markdown: %v\n", err)
+			os.Exit(1)
+		}
+	}
 	if failed > 0 {
 		os.Exit(1)
 	}
 }

+const (
+	statusPassed  = "passed"
+	statusSkipped = "skipped"
+	statusFailed  = "failed"
+)
+
+type conformanceResult struct {
+	Provider string `json:"provider"`
+	Harness  string `json:"harness,omitempty"`
+	Status   string `json:"status"`
+	Error    string `json:"error,omitempty"`
+}
+
+type conformanceSummary struct {
+	Providers    []string            `json:"providers"`
+	Harnesses    []string            `json:"harnesses"`
+	Capabilities []ai.CapabilityRow  `json:"capabilities"`
+	Results      []conformanceResult `json:"results"`
+	Passed       int                 `json:"passed"`
+	Skipped      int                 `json:"skipped"`
+	Failed       int                 `json:"failed"`
+}
+
+func writeSummaryJSON(path string, summary conformanceSummary) error {
+	b, err := json.MarshalIndent(summary, "", "  ")
+	if err != nil {
+		return err
+	}
+	b = append(b, '\n')
+	return os.WriteFile(path, b, 0o644)
+}
+
+func writeCapabilityMarkdown(path string, rows []ai.CapabilityRow) error {
+	return os.WriteFile(path, []byte(capabilityMarkdown(rows)), 0o644)
+}
+
+func writeSummaryMarkdown(path string, summary conformanceSummary) error {
+	var b strings.Builder
+	b.WriteString("# Provider conformance summary\n\n")
+	fmt.Fprintf(&b, "Passed: %d. Skipped providers: %d. Failed: %d.\n\n", summary.Passed, summary.Skipped, summary.Failed)
+	b.WriteString("## Capability matrix\n\n")
+	b.WriteString(capabilityMarkdown(summary.Capabilities))
+	b.WriteString("\n## Harness results\n\n")
+	b.WriteString("| Provider | Harness | Status | Detail |\n")
+	b.WriteString("| --- | --- | --- | --- |\n")
+	for _, result := range summary.Results {
+		harness := result.Harness
+		if harness == "" {
+			harness = "—"
+		}
+		fmt.Fprintf(&b, "| %s | %s | %s | %s |\n", result.Provider, harness, result.Status, markdownCell(result.Error))
+	}
+	return os.WriteFile(path, []byte(b.String()), 0o644)
+}
+
+func capabilityMarkdown(rows []ai.CapabilityRow) string {
+	var b strings.Builder
+	b.WriteString("| Provider | Model | Image | Video | Streaming |\n")
+	b.WriteString("| --- | --- | --- | --- | --- |\n")
+	for _, row := range rows {
+		fmt.Fprintf(&b, "| %s | %s | %s | %s | %s |\n", row.Provider, mark(row.Model), mark(row.Image), mark(row.Video), mark(row.Stream))
+	}
+	return b.String()
+}
+
+func markdownCell(s string) string {
+	if s == "" {
+		return "—"
+	}
+	s = strings.ReplaceAll(s, "|", "\\|")
+	s = strings.ReplaceAll(s, "\n", "<br>")
+	return s
+}
+
+func mark(ok bool) string {
+	if ok {
+		return "✅"
+	}
+	return "—"
+}
+
+func printCapabilityMatrix() {
+	fmt.Println("Provider capability matrix:")
+	fmt.Println("provider     model  image  video  stream")
+	for _, row := range ai.CapabilityRows() {
+		fmt.Printf("%-12s %-5s  %-5s  %-5s  %-6s\n", row.Provider, yesNo(row.Model), yesNo(row.Image), yesNo(row.Video), yesNo(row.Stream))
+	}
+	fmt.Println()
+}
+
+func yesNo(ok bool) string {
+	if ok {
+		return "yes"
+	}
+	return "no"
+}
+
 func validateSelection(providers, harnesses []string) error {
 	if len(providers) == 0 {
 		return fmt.Errorf("no providers selected")
@@ -1,8 +1,13 @@
 package main

 import (
+	"encoding/json"
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
+
+	"go-micro.dev/v6/ai"
 )

 func TestValidateSelectionAcceptsKnownProviderAndHarness(t *testing.T) {
@@ -30,3 +35,115 @@ func TestValidateSelectionRejectsUnsafeHarnessName(t *testing.T) {
 		t.Fatalf("validateSelection error = %q, want invalid harness message", err)
 	}
 }
+
+func TestCapabilityMatrixHasRegisteredProviders(t *testing.T) {
+	rows := ai.CapabilityRows()
+	if len(rows) == 0 {
+		t.Fatal("CapabilityRows returned no providers")
+	}
+
+	var foundOpenAI bool
+	for _, row := range rows {
+		if row.Provider == "openai" {
+			foundOpenAI = true
+			if !row.Model || !row.Image || row.Video {
+				t.Fatalf("openai capabilities = %#v, want model+image only", row.Capabilities)
+			}
+		}
+	}
+	if !foundOpenAI {
+		t.Fatalf("CapabilityRows = %#v, want openai row", rows)
+	}
+}
+
+func TestWriteCapabilityMarkdown(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "capabilities.md")
+	rows := []ai.CapabilityRow{
+		{Provider: "mock", Capabilities: ai.Capabilities{Model: true}},
+		{Provider: "vision", Capabilities: ai.Capabilities{Image: true, Video: true}},
+	}
+	if err := writeCapabilityMarkdown(path, rows); err != nil {
+		t.Fatalf("writeCapabilityMarkdown returned error: %v", err)
+	}
+
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read capabilities markdown: %v", err)
+	}
+	got := string(b)
+	for _, want := range []string{
+		"| Provider | Model | Image | Video | Streaming |",
+		"| mock | ✅ | — | — | — |",
+		"| vision | — | ✅ | ✅ | — |",
+	} {
+		if !strings.Contains(got, want) {
+			t.Fatalf("capabilities markdown = %q, want row %q", got, want)
+		}
+	}
+}
+
+func TestWriteSummaryMarkdown(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "summary.md")
+	summary := conformanceSummary{
+		Capabilities: []ai.CapabilityRow{{Provider: "mock", Capabilities: ai.Capabilities{Model: true}}},
+		Results: []conformanceResult{
+			{Provider: "mock", Harness: "agent-flow", Status: statusPassed},
+			{Provider: "live", Status: statusSkipped, Error: "missing | key"},
+		},
+		Passed:  1,
+		Skipped: 1,
+	}
+	if err := writeSummaryMarkdown(path, summary); err != nil {
+		t.Fatalf("writeSummaryMarkdown returned error: %v", err)
+	}
+
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read summary markdown: %v", err)
+	}
+	got := string(b)
+	for _, want := range []string{
+		"# Provider conformance summary",
+		"Passed: 1. Skipped providers: 1. Failed: 0.",
+		"| mock | ✅ | — | — | — |",
+		"| mock | agent-flow | passed | — |",
+		"| live | — | skipped | missing \\| key |",
+	} {
+		if !strings.Contains(got, want) {
+			t.Fatalf("summary markdown = %q, want %q", got, want)
+		}
+	}
+}
+
+func TestWriteSummaryJSON(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "summary.json")
+	summary := conformanceSummary{
+		Providers: []string{"mock"},
+		Harnesses: []string{"provider-conformance"},
+		Results: []conformanceResult{{
+			Provider: "mock",
+			Harness:  "provider-conformance",
+			Status:   statusPassed,
+		}},
+		Passed: 1,
+	}
+	if err := writeSummaryJSON(path, summary); err != nil {
+		t.Fatalf("writeSummaryJSON returned error: %v", err)
+	}
+
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read summary: %v", err)
+	}
+	if !strings.HasSuffix(string(b), "\n") {
+		t.Fatalf("summary JSON should end with newline: %q", b)
+	}
+
+	var got conformanceSummary
+	if err := json.Unmarshal(b, &got); err != nil {
+		t.Fatalf("summary JSON did not decode: %v", err)
+	}
+	if got.Passed != 1 || len(got.Results) != 1 || got.Results[0].Status != statusPassed {
+		t.Fatalf("summary JSON decoded as %#v, want one passed result", got)
+	}
+}
@@ -50,6 +50,8 @@ guides:
    url: /docs/guides/atlascloud-integration.html
  - title: AI Provider Guide
    url: /docs/guides/ai-provider-guide.html
+  - title: Provider Conformance
+    url: /docs/guides/provider-conformance.html
  - title: Comparison
    url: /docs/guides/comparison.html
  - title: Migration Guides
@@ -80,6 +82,7 @@ search_order:
  - /docs/plugins.html
  - /docs/examples/
  - /docs/examples/realworld/
+  - /docs/guides/provider-conformance.html
  - /docs/guides/comparison.html
  - /docs/guides/migration/
  - /docs/architecture/
@@ -0,0 +1,75 @@
+---
+layout: blog
+title: "How Go Micro Builds Itself"
+permalink: /blog/31
+description: "Go Micro is increasingly built by an autonomous loop of two AI agents — Codex implementing scoped increments, Claude Code orchestrating, the human setting direction. Here's how the loop actually works, including the parts that broke."
+---
+
+# How Go Micro Builds Itself
+
+*June 25, 2026 • By the Go Micro Team*
+
+Go Micro is an agent harness. The most honest test of that claim is to use agents to build it — so increasingly, we do. A scheduled loop of two AI agents now opens issues, writes increments, and merges its own pull requests against this repo, on a cadence, with a human setting direction rather than typing the code.
+
+This isn't a stunt. If a harness is good enough to operate a loop that builds itself, that's evidence it's good enough to operate the loop that builds *your* software. So we pointed the thesis at itself and wired up the loop. This post is how it actually works — including the parts that didn't, because the failure modes are the interesting part.
+
+## Two agents and a human
+
+The work splits across three roles:
+
+- **Codex** is the serial builder. It takes one scoped task at a time, implements it, runs the build, tests, and linter, and opens a pull request.
+- **Claude Code** is the orchestrator: it sets up the machinery, reviews, integrates, and handles the judgment calls Codex shouldn't make alone.
+- **The human** sets direction and owns taste — brand and positioning copy, breaking public API changes, architectural decisions. Those never merge autonomously.
+
+Everything else is automated.
+
+## The mechanism
+
+Each cycle is deliberately boring, which is the point:
+
+1. A scheduled workflow opens a **fresh tracking issue** and dispatches Codex on it with a single instruction: pick the highest-value improvement that advances the [North Star](/docs/guides/agent-harness.html), implement it, verify it builds and passes tests and lint, and open a PR.
+2. Codex does the work on its own branch and opens the PR.
+3. GitHub **native auto-merge** lands it the moment the required CI checks go green — build, tests, golangci-lint. There is no human approval step. **CI is the only gate**, and that's not an approval, it's just a refusal to ship broken code.
+
+Every increment is small, single-concern, and reversible. Nothing clever survives that can't pass the same checks a human contributor's PR would.
+
+## Three altitudes
+
+One loop only produces increments; it doesn't know whether they're adding up to anything. So there are three passes at different altitudes:
+
+- An **architect** pass reviews the whole framework against the thesis every few days — API coherence, gaps in the services → agents → workflows lifecycle, drift — and files scoped issues. It decides *what* to build.
+- The **hourly increment loop** builds those issues.
+- A **DevRel** pass audits the README, website, docs, and blog each day for coherence, and surfaces things worth writing about. (This post is the kind of thing it's meant to catch.)
+
+The architect points, the loop builds, DevRel keeps the story honest. Direction flows down; code flows up.
+
+## The parts that broke
+
+Wiring an autonomous loop is mostly plumbing and failure modes, which is exactly why it's a good test of a harness. A few we hit:
+
+- The agent's "open a pull request" tool turned out to be a **stub** — it recorded the PR's title and body and returned them for a downstream step, but never pushed a branch or called the API. The agent cheerfully reported "opened a PR" every time, and no PR ever appeared. The fix was to stop trusting the tool and have the agent push and open the PR itself.
+- Dispatching every run from a single tracking issue made the agent derive the **same branch name** each time, so the first increment opened a PR and the rest silently collided. One fresh issue per run fixed it.
+- At one point an increment helpfully rewrote the repo's own agent instructions to point *back* at the broken tool. An autonomous loop will faithfully encode its own mistakes, so the guardrails have to be explicit.
+
+None of these are exotic. They're the ordinary reality of operating an agent loop: tools that lie, state that collides, instructions that drift. The things the harness ships — observability, durable runs, resilience, guardrails — are the things you reach for the moment you try to run a loop like this in earnest.
+
+## What it produces
+
+The increments are unglamorous and real. Recent ones hardened the agent run loop with **OpenTelemetry run timelines** and a `micro runs` command to inspect them, correlated those timelines with trace spans, added **retry backoff** to durable flows, and made flow steps **cancellation-safe** so a canceled run stops retrying instead of burning its budget. Each one landed as a small PR that passed CI on its own.
+
+That's the texture of the work: not a model writing a framework in one shot, but a loop making it a little better, continuously, under a gate that keeps it honest.
+
+## The loop is the proof
+
+We think the future of agentic software is scheduled, looping, work-performing agents — not chat. Go Micro is built by exactly that, against its own repo. The human still sets direction and owns the calls that need taste; CI is the gate; everything is reversible. Within those bounds, the harness builds itself.
+
+If it can do that, it can build yours.
+
+---
+
+*Go Micro is an open source agent harness and service framework for Go. [Star us on GitHub](https://github.com/micro/go-micro).*
+
+<div class="post-nav">
+  <div><a href="/blog/30">&larr; Go Micro is an Agent Harness</a></div>
+  <div><a href="/blog/">All Posts</a></div>
+</div>
@@ -11,6 +11,13 @@ permalink: /blog/

 <div class="posts">

+  <article style="margin-bottom: 2rem; padding-bottom: 1.5rem; border-bottom: 1px solid #e5e5e5;">
+    <h2 style="margin: 0 0 0.5rem;"><a href="/blog/31">How Go Micro Builds Itself</a></h2>
+    <p class="meta" style="color: #666; font-size: 0.85rem;">June 25, 2026</p>
+    <p>Go Micro is increasingly built by an autonomous loop of two AI agents — Codex writing scoped increments, Claude Code orchestrating, the human setting direction. Here's how the loop actually works, including the parts that broke.</p>
+    <a href="/blog/31">Read more &rarr;</a>
+  </article>
+
  <article style="margin-bottom: 2rem; padding-bottom: 1.5rem; border-bottom: 1px solid #e5e5e5;">
    <h2 style="margin: 0 0 0.5rem;"><a href="/blog/30">Go Micro is an Agent Harness</a></h2>
    <p class="meta" style="color: #666; font-size: 0.85rem;">June 24, 2026</p>
@@ -66,8 +66,7 @@ import (
 )

 func main() {
-    service := micro.NewService(
-        micro.Name("example"),
+    service := micro.NewService("example",
    )
    service.Init()
    if err := service.Run(); err != nil {
@@ -31,12 +31,11 @@ Use **mDNS as the default registry** for service discovery.

 ```go
 // Default - uses mDNS automatically
-svc := micro.NewService(micro.Name("myservice"))
+svc := micro.NewService("myservice")

 // Production - swap to Consul
 reg := consul.NewConsulRegistry()
-svc := micro.NewService(
-    micro.Name("myservice"),
+svc := micro.NewService("myservice",
    micro.Registry(reg),
 )
 ```
@@ -29,7 +29,7 @@ Implement **progressive configuration** where:

 ### Level 1: Zero Config (Development)
 ```go
-svc := micro.NewService(micro.Name("hello"))
+svc := micro.NewService("hello")
 svc.Run()
 ```

@@ -62,8 +62,7 @@ b := nats.NewNatsBroker(
    nats.DrainConnection(),
 )

-svc := micro.NewService(
-    micro.Name("myservice"),
+svc := micro.NewService("myservice",
    micro.Version("1.2.3"),
    micro.Registry(reg),
    micro.Broker(b),
@@ -38,7 +38,7 @@ import (
 )

 func main() {
-    service := micro.NewService()
+    service := micro.NewService("publisher")
    service.Init()

    // Publish a message
@@ -73,7 +73,7 @@ import (

 func main() {
    b := bnats.NewNatsBroker()
-    svc := micro.NewService(micro.Broker(b))
+    svc := micro.NewService("publisher", micro.Broker(b))
    svc.Init()
    svc.Run()
 }
@@ -88,7 +88,7 @@ import (

 func main() {
    b := rabbitmq.NewBroker()
-    svc := micro.NewService(micro.Broker(b))
+    svc := micro.NewService("publisher", micro.Broker(b))
    svc.Init()
    svc.Run()
 }
@@ -35,8 +35,7 @@ func (g *Greeter) Hello(ctx context.Context, req *struct{}, rsp *struct{Msg stri
 }

 func main() {
-    service := micro.NewService(
-        micro.Name("greeter"),
+    service := micro.NewService("greeter",
    )
    service.Init()
    micro.RegisterHandler(service.Server(), new(Greeter))
@@ -53,8 +53,7 @@ No code changes required. The framework internally wires the selected implementa
 ## Equivalent Code Configuration

 ```go
-service := micro.NewService(
-    micro.Name("helloworld"),
+service := micro.NewService("helloworld",
    micro.Broker(nats.NewBroker()),
    micro.Transport(natstransport.NewTransport()),
    micro.Registry(consul.NewRegistry(registry.Addrs("127.0.0.1:8500"))),
@@ -54,8 +54,7 @@ curl -XPOST \
 Set a fixed address:

 ```go
-svc := micro.NewService(
-    micro.Name("helloworld"),
+svc := micro.NewService("helloworld",
    micro.Address(":8080"),
 )
 ```
@@ -20,7 +20,7 @@ import (

 func main() {
    b := bnats.NewNatsBroker()
-    svc := micro.NewService(micro.Broker(b))
+    svc := micro.NewService("nats-pubsub", micro.Broker(b))
    svc.Init()

    // subscribe
@@ -79,8 +79,7 @@ func main() {
    }
    defer db.Close()

-    svc := micro.NewService(
-        micro.Name("users"),
+    svc := micro.NewService("users",
        micro.Version("1.0.0"),
    )

@@ -172,8 +171,7 @@ func main() {
    }
    defer db.Close()

-    svc := micro.NewService(
-        micro.Name("orders"),
+    svc := micro.NewService("orders",
        micro.Version("1.0.0"),
    )

@@ -254,8 +252,7 @@ func (g *Gateway) CreateOrder(w http.ResponseWriter, r *http.Request) {
 }

 func main() {
-    svc := micro.NewService(
-        micro.Name("api.gateway"),
+    svc := micro.NewService("api.gateway",
    )
    svc.Init()

@@ -34,8 +34,7 @@ import (
 )

 func main() {
-    svc := micro.NewService(
-        micro.Name("myservice"),
+    svc := micro.NewService("myservice",
        micro.BeforeStop(func() error {
            logger.Info("Service stopping, running cleanup...")
            return cleanup()
@@ -233,8 +232,7 @@ func main() {
    app.AddWorker(&Worker{name: "cleanup"})
    app.AddWorker(&Worker{name: "metrics"})
    
-    svc := micro.NewService(
-        micro.Name("myservice"),
+    svc := micro.NewService("myservice",
        micro.BeforeStop(func() error {
            ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
            defer cancel()
@@ -18,7 +18,7 @@ import (

 func main() {
    reg := consul.NewConsulRegistry()
-    svc := micro.NewService(micro.Registry(reg))
+    svc := micro.NewService("consul-registry", micro.Registry(reg))
    svc.Init()
    svc.Run()
 }
@@ -20,7 +20,7 @@ import (

 func main() {
    st := postgres.NewStore()
-    svc := micro.NewService(micro.Store(st))
+    svc := micro.NewService("postgres-store", micro.Store(st))
    svc.Init()

    _ = store.Write(&store.Record{Key: "foo", Value: []byte("bar")})
@@ -18,7 +18,7 @@ import (

 func main() {
    t := tnats.NewTransport()
-    svc := micro.NewService(micro.Transport(t))
+    svc := micro.NewService("nats-transport", micro.Transport(t))
    svc.Init()
    svc.Run()
 }
@@ -71,4 +71,5 @@ harness. When that loop has to touch production, you do.
 - [Agent Loops](agent-loops.html) — run-until-done, with a ceiling
 - [Plan & Delegate](plan-delegate.html)
 - [Agent Guardrails](agent-guardrails.html)
+- [Provider Conformance](provider-conformance.html) — verified provider behavior
 - [Roadmap](/docs/roadmap.html)
@@ -29,23 +29,22 @@ runtime tooling and docs can report what is actually available after blank
 imports are linked in:

 ```go
-matrix := ai.CapabilityMatrix()
-for provider, caps := range matrix {
-    fmt.Printf("%s: chat=%t image=%t video=%t\n", provider, caps.Model, caps.Image, caps.Video)
+for _, row := range ai.CapabilityRows() {
+    fmt.Printf("%s: chat=%t image=%t video=%t stream=%t\n", row.Provider, row.Model, row.Image, row.Video, row.Stream)
 }
 ```

 The built-in providers currently register these capability interfaces:

-| Provider | Chat/text (`ai.Model`) | Image (`ai.ImageModel`) | Video (`ai.VideoModel`) |
-| --- | --- | --- | --- |
-| `anthropic` | Yes | No | No |
-| `atlascloud` | Yes | Yes | Yes |
-| `gemini` | Yes | No | No |
-| `groq` | Yes | No | No |
-| `mistral` | Yes | No | No |
-| `openai` | Yes | Yes | No |
-| `together` | Yes | No | No |
+| Provider | Chat/text (`ai.Model`) | Image (`ai.ImageModel`) | Video (`ai.VideoModel`) | Streaming (`ai.Stream`) |
+| --- | --- | --- | --- | --- |
+| `anthropic` | Yes | No | No | No |
+| `atlascloud` | Yes | Yes | Yes | No |
+| `gemini` | Yes | No | No | No |
+| `groq` | Yes | No | No | No |
+| `mistral` | Yes | No | No | No |
+| `openai` | Yes | Yes | No | No |
+| `together` | Yes | No | No | No |

 ## Step 1: Implement the `ai.Model` Interface

@@ -97,7 +97,7 @@ func (s *MyService) DoThing(ctx context.Context, req *Request, rsp *Response) er
 }

 func main() {
-    svc := micro.NewService(micro.Name("myservice"))
+    svc := micro.NewService("myservice")
    svc.Init()
    svc.Handle(new(MyService))
    svc.Run()
@@ -140,7 +140,7 @@ import (
    grpcClient "go-micro.dev/v6/client/grpc"
 )

-svc := micro.NewService(
+svc := micro.NewService("myservice",
    micro.Server(grpcServer.NewServer()),
    micro.Client(grpcClient.NewClient()),
 )
@@ -234,11 +234,11 @@ mesh / runtime and let ADK (or any A2A agent) plug into it.
 **Go Micro**: Built-in with plugins
 ```go
 // Zero-config for dev
-svc := micro.NewService(micro.Name("myservice"))
+svc := micro.NewService("myservice")

 // Consul for production
 reg := consul.NewRegistry()
-svc := micro.NewService(micro.Registry(reg))
+svc := micro.NewService("myservice", micro.Registry(reg))
 ```

 **go-kit**: Bring your own
@@ -19,8 +19,7 @@ The gRPC **transport** uses the gRPC protocol as a communication layer, similar
 import "go-micro.dev/v6/transport/grpc"

 t := grpc.NewTransport()
-service := micro.NewService(
-    micro.Name("helloworld"),
+service := micro.NewService("helloworld",
    micro.Transport(t),
 )
 ```
@@ -42,15 +41,12 @@ import (
    grpcClient "go-micro.dev/v6/client/grpc"
 )

-service := micro.NewService(
-    micro.Server(grpcServer.NewServer()),  // Server must come before Name
+service := micro.NewService("helloworld",
+    micro.Server(grpcServer.NewServer()),
    micro.Client(grpcClient.NewClient()),
-    micro.Name("helloworld"),
 )
 ```

-> **Important**: The `micro.Server()` option must be specified **before** `micro.Name()`. This is because `micro.Name()` sets the name on the current server, and if `micro.Server()` comes after, it replaces the server with a new one that has no name set.
-
 ## When to Use Which

 | Use Case | Solution |
@@ -123,9 +119,8 @@ func (s *Say) Hello(ctx context.Context, req *pb.Request, rsp *pb.Response) erro
 func main() {
    // Create service with gRPC server for native gRPC compatibility
    // Note: Server must be set before Name to ensure the name is applied to the gRPC server
-    service := micro.NewService(
+    service := micro.NewService("helloworld",
        micro.Server(grpcServer.NewServer()),
-        micro.Name("helloworld"),
        micro.Address(":8080"),
    )

@@ -158,9 +153,8 @@ import (

 func main() {
    // Create service with gRPC client
-    service := micro.NewService(
+    service := micro.NewService("helloworld.client",
        micro.Client(grpcClient.NewClient()),
-        micro.Name("helloworld.client"),
    )
    service.Init()

@@ -207,10 +201,9 @@ import (
 )

 func main() {
-    service := micro.NewService(
-        micro.Server(grpcServer.NewServer()),  // Server first
+    service := micro.NewService("helloworld",
+        micro.Server(grpcServer.NewServer()),
        micro.Client(grpcClient.NewClient()),
-        micro.Name("helloworld"),              // Name after Server
        micro.Address(":8080"),
    )

@@ -239,7 +232,7 @@ ERROR:
 ```go
 // Wrong - uses transport
 t := grpc.NewTransport()
-service := micro.NewService(
+service := micro.NewService("helloworld",
    micro.Transport(t),
 )
 ```
@@ -250,7 +243,7 @@ To:
 // Correct - uses server
 import grpcServer "go-micro.dev/v6/server/grpc"

-service := micro.NewService(
+service := micro.NewService("helloworld",
    micro.Server(grpcServer.NewServer()),
 )
 ```
@@ -270,36 +263,12 @@ import "go-micro.dev/v6/server/grpc"
 import "go-micro.dev/v6/client/grpc"
 ```

-### Option Ordering Issue
-
-If the gRPC server is working but your service has no name or is not being found in the registry:
-
-**Cause**: The `micro.Server()` option is specified **after** `micro.Name()`.
-
-When options are processed, `micro.Name()` sets the name on the current server. If `micro.Server()` comes later, it replaces the server with a new one that doesn't have the name set.
-
-**Solution**: Always specify `micro.Server()` **before** `micro.Name()`:
-
-```go
-// Wrong - server replaces the one with the name set
-service := micro.NewService(
-    micro.Name("helloworld"),              // Sets name on default server
-    micro.Server(grpcServer.NewServer()),  // Replaces server, name is lost!
-)
-
-// Correct - name is set on the gRPC server
-service := micro.NewService(
-    micro.Server(grpcServer.NewServer()),  // Set server first
-    micro.Name("helloworld"),              // Name is now applied to gRPC server
-)
-```
-
 ### Service Name vs Package Name

-When creating a client to call another service, use the **service name** (set via `micro.Name()`), not the proto package name:
+When creating a client to call another service, use the **service name** passed to `micro.NewService`, not the proto package name:

 ```go
-// If the server was started with micro.Name("helloworld")
+// If the server was started with micro.NewService("helloworld", ...)
 sayService := pb.NewSayService("helloworld", service.Client())  // Use service name

 // NOT the package name from the proto file
@@ -319,8 +319,7 @@ import (
 )

 func main() {
-    service := micro.NewService(
-        micro.Name("tasks"),
+    service := micro.NewService("tasks",
        micro.Address(":8081"),
    )
    service.Init()
@@ -128,8 +128,7 @@ func (s *Greeter) SayHello(ctx context.Context, req *pb.HelloRequest, rsp *pb.He
 }

 func main() {
-    svc := micro.NewService(
-        micro.Name("greeter"),
+    svc := micro.NewService("greeter",
    )
    svc.Init()

@@ -159,7 +158,7 @@ rsp, err := client.SayHello(context.Background(), &pb.HelloRequest{Name: "John"}

 **Go Micro client:**
 ```go
-svc := micro.NewService(micro.Name("client"))
+svc := micro.NewService("client")
 svc.Init()

 client := pb.NewGreeterService("greeter", svc.Client())
@@ -185,8 +184,7 @@ import (
    grpcserver "go-micro.dev/v6/server/grpc"
 )

-svc := micro.NewService(
-    micro.Name("greeter"),
+svc := micro.NewService("greeter",
    micro.Client(grpcclient.NewClient()),
    micro.Server(grpcserver.NewServer()),
 )
@@ -268,8 +266,7 @@ defer client.Agent().ServiceDeregister("greeter-1")
 import "go-micro.dev/v6/registry/consul"

 reg := consul.NewConsulRegistry()
-svc := micro.NewService(
-    micro.Name("greeter"),
+svc := micro.NewService("greeter",
    micro.Registry(reg),
 )

@@ -293,7 +290,7 @@ svc.Run()
 import "go-micro.dev/v6/selector"

 // Client-side load balancing built-in
-svc := micro.NewService(
+svc := micro.NewService("greeter",
    micro.Selector(selector.NewSelector(
        selector.SetStrategy(selector.RoundRobin),
    )),
@@ -362,11 +359,10 @@ lis, _ := net.Listen("tcp", ":50051")
 **Go Micro**: Automatic or explicit
 ```go
 // Let Go Micro choose
-svc := micro.NewService(micro.Name("greeter"))
+svc := micro.NewService("greeter")

 // Or specify
-svc := micro.NewService(
-    micro.Name("greeter"),
+svc := micro.NewService("greeter",
    micro.Address(":50051"),
 )
 ```
@@ -390,7 +386,7 @@ Ensure both use protobuf:
 ```go
 import "go-micro.dev/v6/codec/proto"

-svc := micro.NewService(
+svc := micro.NewService("greeter",
    micro.Codec("application/protobuf", proto.Marshaler{}),
 )
 ```
@@ -0,0 +1,109 @@
+---
+layout: default
+---
+
+# Provider Conformance Matrix
+
+Go Micro treats model providers as interchangeable pieces of the same agent
+harness: services expose tools, agents reason over them, and workflows stitch the
+work together. The conformance harness keeps that promise honest by running the
+same deterministic services → agents → workflows scenarios against every
+configured provider.
+
+The live harness is in `internal/harness/provider-conformance`. It skips
+providers without API keys by default, so it is safe to run locally, and it fails
+when any configured provider breaks the shared contract.
+
+```sh
+go run ./internal/harness/provider-conformance
+```
+
+For a no-key smoke test of the same harness wiring, run the mock provider:
+
+```sh
+go run ./internal/harness/provider-conformance -providers mock
+```
+
+## Status legend
+
+| Status | Meaning |
+| --- | --- |
+| ✅ Verified | Covered by the provider-conformance harness for configured live providers. |
+| ⚠️ Unverified | Implemented in the public API, but not yet exercised by provider conformance. |
+| — Unsupported | Not exposed by that provider integration today. |
+
+## Harness coverage by capability
+
+These rows describe what the conformance harness verifies today. A provider is
+considered conformant when the configured-key run passes all selected harnesses.
+
+| Capability | Harness coverage | Notes |
+| --- | --- | --- |
+| Simple generation | ✅ Verified | Each harness asks the provider to produce an agent response through `ai.Model`. |
+| Service tool calls | ✅ Verified | Harness services are discovered and invoked as model-selected tools. |
+| Multi-step tool use | ✅ Verified | The `universe` and `plan-delegate` harnesses require more than one service/tool action. |
+| `plan` | ✅ Verified | `plan-delegate` verifies that the conductor agent stores a plan in scoped state. |
+| `delegate` | ✅ Verified | `plan-delegate` verifies agent-to-agent delegation over real RPC. |
+| Guardrail/stop behavior | ✅ Verified | `universe` runs with guardrails enabled and asserts the guarded path completes. |
+| Streaming | ⚠️ Unverified | `ai.Model.Stream` exists on the interface, but end-to-end streaming conformance is a roadmap item. |
+| Structured errors | ⚠️ Unverified | Error handling is covered by normal test suites, but provider conformance does not yet compare structured provider errors. |
+
+## Provider capability matrix
+
+This matrix combines the registered provider interfaces with the conformance
+coverage above. The chat/text column is the harness path: when the provider has a
+configured key, the conformance command exercises the verified rows in the
+previous section.
+
+| Provider | Chat/text agent harness | Image | Video | Streaming | Structured errors |
+| --- | --- | --- | --- | --- | --- |
+| `anthropic` | ✅ Verified when configured | — Unsupported | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
+| `openai` | ✅ Verified when configured | ✅ Registered | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
+| `gemini` | ✅ Verified when configured | — Unsupported | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
+| `groq` | ✅ Verified when configured | — Unsupported | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
+| `mistral` | ✅ Verified when configured | — Unsupported | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
+| `together` | ✅ Verified when configured | — Unsupported | — Unsupported | ⚠️ Unverified | ⚠️ Unverified |
+| `atlascloud` | ✅ Verified when configured | ✅ Registered | ✅ Registered | ⚠️ Unverified | ⚠️ Unverified |
+
+## Running a focused check
+
+Use `-providers` to select a provider and `-harnesses` to narrow the scenario:
+
+```sh
+go run ./internal/harness/provider-conformance \
+  -providers openai,anthropic \
+  -harnesses agent-flow,plan-delegate
+```
+
+By default missing live-provider keys are reported as skips. Add
+`-require-configured` in CI when a selected provider must be present:
+
+```sh
+go run ./internal/harness/provider-conformance \
+  -providers openai \
+  -require-configured
+```
+
+The command also prints the registered model, image, and video provider
+capabilities before running conformance. Disable that with `-capabilities=false`
+when you only want pass/fail output.
+
+For automation, add `-summary-json` to capture the selected providers,
+harnesses, registered capability rows, and pass/skip/fail results in a stable
+machine-readable file. Add `-capabilities-markdown` when you also want a
+ready-to-publish Markdown support table for release notes, docs, or issue
+updates:
+
+```sh
+go run ./internal/harness/provider-conformance \
+  -providers mock \
+  -summary-json provider-conformance-summary.json \
+  -capabilities-markdown provider-capabilities.md
+```
+
+## Related docs
+
+- [The Agent Harness](agent-harness.html)
+- [Agents and Workflows](agents-and-workflows.html)
+- [AI Provider Guide](ai-provider-guide.html)
+- [Roadmap](/docs/roadmap.html)
@@ -0,0 +1,47 @@
+package guides_test
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"go-micro.dev/v6/ai"
+	_ "go-micro.dev/v6/ai/anthropic"
+	_ "go-micro.dev/v6/ai/atlascloud"
+	_ "go-micro.dev/v6/ai/gemini"
+	_ "go-micro.dev/v6/ai/groq"
+	_ "go-micro.dev/v6/ai/mistral"
+	_ "go-micro.dev/v6/ai/openai"
+	_ "go-micro.dev/v6/ai/together"
+)
+
+func TestAIProviderGuideCapabilityMatrixMatchesRegistry(t *testing.T) {
+	_, filename, _, ok := runtime.Caller(0)
+	if !ok {
+		t.Fatal("runtime.Caller failed")
+	}
+
+	guidePath := filepath.Join(filepath.Dir(filename), "ai-provider-guide.md")
+	b, err := os.ReadFile(guidePath)
+	if err != nil {
+		t.Fatalf("read AI provider guide: %v", err)
+	}
+	guide := string(b)
+
+	for _, row := range ai.CapabilityRows() {
+		want := fmt.Sprintf("| `%s` | %s | %s | %s | %s |", row.Provider, yesNo(row.Model), yesNo(row.Image), yesNo(row.Video), yesNo(row.Stream))
+		if !strings.Contains(guide, want) {
+			t.Fatalf("AI provider guide capability matrix is stale; missing row %q", want)
+		}
+	}
+}
+
+func yesNo(ok bool) string {
+	if ok {
+		return "Yes"
+	}
+	return "No"
+}
@@ -42,10 +42,10 @@ Because every endpoint is already an MCP tool, the gateway is where you charge.

 ```bash
 micro mcp serve --address :3000 \
-    --x402-pay-to 0xYourAddress \
-    --x402-network solana \
-    --x402-amount 10000 \
-    --x402-facilitator https://facilitator.example
+    --x402_pay_to 0xYourAddress \
+    --x402_network solana \
+    --x402_amount 10000 \
+    --x402_facilitator https://facilitator.example
 ```

 ## A shoppable catalog
@@ -69,7 +69,7 @@ Free tools carry no `payment` block. This is the foundation for a tool marketpla
 Different tools can cost different amounts. Pricing is an **operator** concern — the payTo address is the operator's, and amounts change without redeploying anyone's service — so it's configured at the gateway with a file, the same way per-tool scopes and rate limits are. Point the gateway at an x402 config:

 ```bash
-micro mcp serve --address :3000 --x402-config x402.json
+micro mcp serve --address :3000 --x402_config x402.json
 ```

 ```json
@@ -85,7 +85,7 @@ micro mcp serve --address :3000 --x402-config x402.json
 }
 ```

-`amount` is the default (here `"0"` — free unless priced), and `amounts` sets per-tool overrides keyed by tool name. There is no "pricing" abstraction; it's the x402 `amount`, resolved per tool, in the protocol's own vocabulary. The standalone gateway accepts the same file via `--x402-config` or the `X402_CONFIG` environment variable.
+`amount` is the default (here `"0"` — free unless priced), and `amounts` sets per-tool overrides keyed by tool name. There is no "pricing" abstraction; it's the x402 `amount`, resolved per tool, in the protocol's own vocabulary. `micro mcp serve` accepts the file via `--x402_config`; the standalone gateway accepts the same file via `--x402-config` or the `X402_CONFIG` environment variable.

 ## Paying for tools (the consumer side)

@@ -34,7 +34,7 @@ about the framework.
 - [Transport](transport.html)
 - [Store](store.html)
 - [Plugins](plugins.html)
- [Examples](examples/index.md)
+- [Examples](examples/)

 ## Development & Deployment

@@ -52,9 +52,9 @@ about the framework.
 ## Advanced

 - [Framework Comparison](guides/comparison.html)
- [Architecture Decisions](architecture/index.md)
- [Real-World Examples](examples/realworld/index.md)
- [Migration Guides](guides/migration/index.md)
+- [Architecture Decisions](architecture/)
+- [Real-World Examples](examples/realworld/)
+- [Migration Guides](guides/migration/)
 - [Observability](observability.html)
 - [Contributing](contributing.html)
 - [Roadmap](roadmap.html)
@@ -98,7 +98,7 @@ Choose based on your deployment:
 import "go-micro.dev/v6/server/grpc"

 // Use gRPC for better performance
-service := micro.NewService(
+service := micro.NewService("performance-example",
    micro.Server(grpc.NewServer()),
 )
 ```
@@ -26,7 +26,7 @@ import (

 func main() {
    reg := consul.NewConsulRegistry()
-    svc := micro.NewService(
+    svc := micro.NewService("plugin-example",
        micro.Registry(reg),
    )
    svc.Init()
@@ -43,7 +43,7 @@ import (

 func main() {
    reg := etcd.NewRegistry()
-    svc := micro.NewService(micro.Registry(reg))
+    svc := micro.NewService("plugin-example", micro.Registry(reg))
    svc.Init()
    svc.Run()
 }
@@ -60,7 +60,7 @@ import (

 func main() {
    b := bnats.NewNatsBroker()
-    svc := micro.NewService(micro.Broker(b))
+    svc := micro.NewService("plugin-example", micro.Broker(b))
    svc.Init()
    svc.Run()
 }
@@ -75,7 +75,7 @@ import (

 func main() {
    b := rabbitmq.NewBroker()
-    svc := micro.NewService(micro.Broker(b))
+    svc := micro.NewService("plugin-example", micro.Broker(b))
    svc.Init()
    svc.Run()
 }
@@ -90,7 +90,7 @@ import (

 func main() {
    t := tnats.NewTransport()
-    svc := micro.NewService(micro.Transport(t))
+    svc := micro.NewService("plugin-example", micro.Transport(t))
    svc.Init()
    svc.Run()
 }
@@ -108,7 +108,7 @@ import (
 )

 func main() {
-    svc := micro.NewService(
+    svc := micro.NewService("plugin-example",
        micro.Server(grpcServer.NewServer()),
        micro.Client(grpcClient.NewClient()),
    )
@@ -130,7 +130,7 @@ import (

 func main() {
    st := postgres.NewStore()
-    svc := micro.NewService(micro.Store(st))
+    svc := micro.NewService("plugin-example", micro.Store(st))
    svc.Init()
    svc.Run()
 }
@@ -145,7 +145,7 @@ import (

 func main() {
    st := natsjskv.NewStore()
-    svc := micro.NewService(micro.Store(st))
+    svc := micro.NewService("plugin-example", micro.Store(st))
    svc.Init()
    svc.Run()
 }
@@ -53,7 +53,7 @@ import (

 func main() {
    reg := consul.NewRegistry()
-    service := micro.NewService(
+    service := micro.NewService("registry-example",
        micro.Registry(reg),
    )
    service.Init()
@@ -36,7 +36,7 @@ import (
 )

 func main() {
-    service := micro.NewService()
+    service := micro.NewService("store-example")
    service.Init()

    // Write a record
@@ -64,7 +64,7 @@ import (

 func main() {
    st := postgres.NewStore()
-    svc := micro.NewService(micro.Store(st))
+    svc := micro.NewService("store-example", micro.Store(st))
    svc.Init()
    svc.Run()
 }
@@ -79,7 +79,7 @@ import (

 func main() {
    st := natsjskv.NewStore()
-    svc := micro.NewService(micro.Store(st))
+    svc := micro.NewService("store-example", micro.Store(st))
    svc.Init()
    svc.Run()
 }
@@ -31,11 +31,9 @@ import (
    grpcClient "go-micro.dev/v6/client/grpc"
 )

-// Important: Server must be specified before Name
-service := micro.NewService(
+service := micro.NewService("myservice",
    micro.Server(grpcServer.NewServer()),
    micro.Client(grpcClient.NewClient()),
-    micro.Name("myservice"),
 )
 ```

@@ -59,7 +57,7 @@ import (

 func main() {
    t := grpc.NewTransport()
-    service := micro.NewService(
+    service := micro.NewService("transport-example",
        micro.Transport(t),
    )
    service.Init()
@@ -76,7 +74,7 @@ import (

 func main() {
    t := tnats.NewTransport()
-    service := micro.NewService(micro.Transport(t))
+    service := micro.NewService("transport-example", micro.Transport(t))
    service.Init()
    service.Run()
 }
@@ -12,6 +12,7 @@ import (
 	"go-micro.dev/v6/server"
 	"go-micro.dev/v6/service"
 	"go-micro.dev/v6/store"
+	"go.opentelemetry.io/otel/trace"
 )

 type serviceKey struct{}
@@ -201,6 +202,9 @@ func FlowWithCheckpoint(c Checkpoint) FlowOption { return flow.WithCheckpoint(c)
 // are always kept). Default: retain all.
 func FlowDeleteOnSuccess() FlowOption { return flow.DeleteOnSuccess() }

+// FlowTraceProvider enables OpenTelemetry spans for stepped flow runs and steps.
+func FlowTraceProvider(tp trace.TracerProvider) FlowOption { return flow.TraceProvider(tp) }
+
 // FlowCall is a step action: an RPC to a service endpoint, sending the
 // state data as the request and storing the response.
 func FlowCall(service, endpoint string) FlowStepFunc { return flow.Call(service, endpoint) }
Author	SHA1	Message	Date
Codex	d3b246722b	docs: align public x402 flag examples Harness (E2E) / Provider harnesses (live LLM conformance) (push) Waiting to run Details Harness (E2E) / Harnesses (mock LLM) (push) Waiting to run Details Lint / golangci-lint (push) Waiting to run Details Run Tests / Unit Tests (push) Waiting to run Details Run Tests / Etcd Integration Tests (push) Waiting to run Details	2026-06-27 08:08:24 +00:00
Asim Aslam	ba231efe71	Update README.md	2026-06-27 07:08:08 +01:00
Asim Aslam	f755eadd47	Propagate flow checkpoint failures (#3150 ) Co-authored-by: Codex <codex@openai.com>	2026-06-27 06:55:56 +01:00
Asim Aslam	467c937873	Improve flow run history validation (#3148 ) Co-authored-by: Codex <codex@openai.com>	2026-06-27 04:55:49 +01:00
Asim Aslam	3f45771840	Publish provider conformance summaries (#3146 ) Co-authored-by: Codex <codex@openai.com>	2026-06-27 03:29:12 +01:00
Asim Aslam	c9e045961d	Add flow run stage filtering (#3144 ) Co-authored-by: Codex <codex@openai.com>	2026-06-27 02:28:39 +01:00
Asim Aslam	590aacb518	docs: keep AI provider capability matrix verified (#3142 ) Co-authored-by: Codex <codex@openai.com>	2026-06-27 00:58:39 +01:00
Asim Aslam	87eb5ce665	Add filters for flow run history (#3140 ) Co-authored-by: Codex <codex@openai.com>	2026-06-27 00:00:58 +01:00
Asim Aslam	ed904aa6ad	Propagate flow run lineage to agent chats (#3138 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 23:04:18 +01:00
Asim Aslam	59d028b8e1	test ai retry policy semantics (#3136 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 22:16:59 +01:00
Asim Aslam	19818ad638	Expose streaming in provider capabilities (#3134 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 21:18:38 +01:00
Asim Aslam	993ce668b2	Add provider capability markdown export (#3132 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 20:20:08 +01:00
Asim Aslam	1d412fa6f5	Trigger test workflow on PR updates (#3130 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 19:14:39 +01:00
Asim Aslam	271c27c44f	Validate durable flow step names (#3128 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 18:18:06 +01:00
Asim Aslam	cefc9438c4	Add JSON output for AI provider capabilities (#3126 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 17:31:18 +01:00
Asim Aslam	af39aac297	Add provider conformance JSON summary (#3124 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 16:31:25 +01:00
Asim Aslam	41717aaa9a	ci: run 0-to-1 scaffold contract in harness (#3122 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 15:26:25 +01:00
Asim Aslam	5d1137d8f9	docs: add provider conformance matrix (#3106 ) Co-authored-by: Codex <codex@openai.com> Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>	2026-06-26 14:30:51 +01:00
Asim Aslam	a14b3e79e2	docs: add provider conformance matrix (#3120 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 14:23:56 +01:00
Asim Aslam	130022e544	Record full agent timelines without tracing (#3118 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 13:27:08 +01:00
Asim Aslam	0d3f3f2be5	Record agent run timelines without tracing (#3116 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 12:35:03 +01:00
Asim Aslam	ae91863343	Add trace filter for agent runs (#3114 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 10:50:49 +01:00
Asim Aslam	72f8067e57	docs: finish constructor example cleanup (#3112 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 09:30:58 +01:00
Asim Aslam	8533306e64	docs: align service constructor examples (#3111 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 09:29:36 +01:00
Asim Aslam	384987da9f	docs: align service constructor examples (#3110 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 09:26:40 +01:00
Asim Aslam	ddde9472fc	Expose agent chat run identifiers (#3108 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 08:53:33 +01:00
Asim Aslam	d7a74735c8	Add AI provider capability command (#3104 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 04:55:16 +01:00
Asim Aslam	581b2120a3	Verify zero-to-hero harness via workflow (#3102 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 03:29:00 +01:00
Asim Aslam	871af7e6d3	Add pending filter for flow run history (#3100 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 02:35:50 +01:00
Asim Aslam	9d39ed3292	Add OpenTelemetry spans for stepped flows (#3098 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 01:10:11 +01:00
Asim Aslam	d8f711431f	agent: stop canceled tool execution (#3096 ) Co-authored-by: Codex <codex@openai.com>	2026-06-26 00:07:26 +01:00
Asim Aslam	5d22cd4a5b	Correlate agent trace spans (#3094 ) Co-authored-by: Codex <codex@openai.com>	2026-06-25 23:09:39 +01:00
Asim Aslam	f1f987cb8d	provider conformance: print capability matrix (#3092 ) Co-authored-by: Codex <codex@openai.com>	2026-06-25 22:18:34 +01:00
Asim Aslam	7b9c583dcf	blog: "How Go Micro Builds Itself" — the autonomous Codex loop (#3090 ) A post on how the framework is increasingly built by an autonomous loop of two AI agents (Codex implementing scoped increments, Claude Code orchestrating, the human setting direction): the dispatch→build→auto-merge mechanism, the three altitudes (architect/increment/DevRel), the failure modes we hit wiring it up, and the concrete increments it produces. Claude-Session: https://claude.ai/code/session_01CmdEY7pYmV5zzwCjNJ4ykL Co-authored-by: Claude <noreply@anthropic.com>	2026-06-25 21:59:00 +01:00
Asim Aslam	b7f1ac6d6d	Add flow run correlation to step contexts (#3089 ) Co-authored-by: Codex <codex@openai.com>	2026-06-25 21:20:38 +01:00
Asim Aslam	fb14ccbc17	Add deterministic AI capability rows (#3087 ) Co-authored-by: Codex <codex@openai.com>	2026-06-25 20:21:00 +01:00
Asim Aslam	5f40cae7af	ci: add DevRel + Architect overseer passes to the loop (#3085 ) The hourly loop ships increments but nothing watches the whole. Add two periodic high-altitude passes, same dispatch mechanism (fresh issue → @codex): - devrel-review.yml (daily): audits README, website, docs, blog for coherence with the North Star, README crispness, and blog-worthy material. Safe alignment/crispness fixes auto-merge; brand/positioning copy and blog drafts are surfaced in a report for the human, never auto-merged. - architecture-review.yml (every ~3 days): reviews the framework/harness against the thesis and files scoped follow-up issues that feed the increment loop. It does not make breaking/architectural changes itself. Documented both in CONTINUOUS_IMPROVEMENT.md (Overseer passes). Claude-Session: https://claude.ai/code/session_01CmdEY7pYmV5zzwCjNJ4ykL Co-authored-by: Claude <noreply@anthropic.com>	2026-06-25 19:42:58 +01:00
Asim Aslam	496d5b7644	Show parent agent runs in CLI history (#3084 ) Co-authored-by: Codex <codex@openai.com>	2026-06-25 19:28:32 +01:00