docs(priorities): advance agent durability queue

2026-06-30 13:39:47 +00:00
83 changed files with 172 additions and 2548 deletions
@@ -48,4 +48,4 @@ Add any other context about the problem here.
 - [Troubleshooting Guide](https://github.com/micro/go-micro/tree/master/internal/website/docs/getting-started.md)
 - [Examples](https://github.com/micro/go-micro/tree/master/examples)
 - [API Reference](https://pkg.go.dev/go-micro.dev/v5)
- [Discord Community](https://discord.gg/G8Gk5j3uXr)
+- [Discord Community](https://discord.gg/WeMU5AGxD)
@@ -39,4 +39,4 @@ Add any other context, code examples, or screenshots about the feature request h
 - [Roadmap](https://github.com/micro/go-micro/blob/master/ROADMAP.md)
 - [Contributing Guide](https://github.com/micro/go-micro/blob/master/CONTRIBUTING.md)
 - [Architecture Docs](https://github.com/micro/go-micro/tree/master/internal/website/docs/architecture.md)
- [Discord Community](https://discord.gg/G8Gk5j3uXr)
+- [Discord Community](https://discord.gg/WeMU5AGxD)
@@ -1,4 +1,4 @@
-name: "Loop: Architect (Planner)"
+name: Architecture Review

 # Continuous high-altitude oversight of the whole framework and harness — the
 # "founder lens" of the autonomous loop (internal/docs/CONTINUOUS_IMPROVEMENT.md).
@@ -48,4 +48,4 @@ jobs:
          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 — the founder lens — for go-micro, running continuously alongside the builders. Hold the whole picture: how the harness, the framework, and the developer UX fit together cohesively, what is in flight and what just merged, what to prioritize next on the roadmap, and what is missing or has drifted. Each run: (1) TRACK STATE — scan recently merged PRs and open codex PRs/issues to see what shipped and what is being built right now, so the queue reflects reality (drop done items, don't re-queue in-flight work). (2) ASSESS against the North Star in internal/docs/THESIS.md — lead with its Mission (*the problem we solve: make building an agent as easy as building a service, on one runtime*) and re-derive alignment from the CANON it names (the blog under internal/website/blog, the README, and the website — read these, don't rely on THESIS.md alone), then ROADMAP.md (Now → Next → Later). Judge every priority against the mission: does it make the services → agents → workflows lifecycle simpler, more cohesive, and more operable? CURRENT GOAL — DEVELOPER ADOPTION: the framework's depth is strong but its ON-RAMP is the gap, and the strategic priority right now is developer adoption / reviving real usage. Weight the developer on-ramp and DX — a walkable first-agent tutorial, discoverable examples, docs wayfinding/nav, install friction, debugging, the 0→1 and 0→hero experience — AT LEAST as highly as internal hardening. A developer succeeding on their first agent matters more right now than another conformance/observability/interop increment; do NOT let the queue fill entirely with internal depth work — keep open adoption/on-ramp items near the top. Look at coherence and seams across the core packages (agent, ai, flow, gateway/mcp, gateway/a2a, model, server, store, registry), the dev inner loop (scaffold → run → chat → inspect → deploy), missing pieces, duplication/drift, and realignment. Flag drift in EITHER direction: work drifting from the mission, or the North Star/website drifting from the lived story in the blog (which needs re-grounding in the canon). (3) MAINTAIN THE QUEUE in internal/docs/PRIORITIES.md — a SINGLE ordered list, highest-value first, each item linking a scoped CI-verifiable issue (#N); roadmap phase is the primary ordering, internal findings (cohesion gaps, DX friction, missing pieces) interleaved by value. For any prioritized gap that has no issue yet, file one: \`gh issue create --label codex --label enhancement --title \"<scoped task>\" --body \"<goal, scope, acceptance criteria>\"\`. OUTPUT: post a concise assessment as a comment on this issue (#$ISSUE_NUM) — what shipped, what's in flight, the top risks/gaps/missing pieces, and the reasoning behind the ranking. If the ranking actually changed, open ONE PR for PRIORITIES.md: \`git switch -c codex/architect-$ISSUE_NUM\`, \`git push -u origin codex/architect-$ISSUE_NUM\`, \`gh pr create --base master --label codex --title \"<title>\" --body \"<summary, Closes #$ISSUE_NUM>\"\`, then \`gh pr merge --squash --auto --delete-branch\`. If the queue is already accurate and correctly ranked, do NOT open a PR — just close this issue (\`gh issue close $ISSUE_NUM\`). Do NOT make breaking public-API or architectural changes yourself — surface those in the assessment as notes for the human, never as auto-merged changes. Do not use the make_pr tool (it is a no-op stub)."
+          "@codex Act as the architect — the founder lens — for go-micro, running continuously alongside the builders. Hold the whole picture: how the harness, the framework, and the developer UX fit together cohesively, what is in flight and what just merged, what to prioritize next on the roadmap, and what is missing or has drifted. Each run: (1) TRACK STATE — scan recently merged PRs and open codex PRs/issues to see what shipped and what is being built right now, so the queue reflects reality (drop done items, don't re-queue in-flight work). (2) ASSESS against the North Star in internal/docs/THESIS.md — lead with its Mission (*the problem we solve: make building an agent as easy as building a service, on one runtime*) and re-derive alignment from the CANON it names (the blog under internal/website/blog, the README, and the website — read these, don't rely on THESIS.md alone), then ROADMAP.md (Now → Next → Later). Judge every priority against the mission: does it make the services → agents → workflows lifecycle simpler, more cohesive, and more operable? Look at coherence and seams across the core packages (agent, ai, flow, gateway/mcp, gateway/a2a, model, server, store, registry), the dev inner loop (scaffold → run → chat → inspect → deploy), missing pieces, duplication/drift, and realignment. Flag drift in EITHER direction: work drifting from the mission, or the North Star/website drifting from the lived story in the blog (which needs re-grounding in the canon). (3) MAINTAIN THE QUEUE in internal/docs/PRIORITIES.md — a SINGLE ordered list, highest-value first, each item linking a scoped CI-verifiable issue (#N); roadmap phase is the primary ordering, internal findings (cohesion gaps, DX friction, missing pieces) interleaved by value. For any prioritized gap that has no issue yet, file one: \`gh issue create --label codex --label enhancement --title \"<scoped task>\" --body \"<goal, scope, acceptance criteria>\"\`. OUTPUT: post a concise assessment as a comment on this issue (#$ISSUE_NUM) — what shipped, what's in flight, the top risks/gaps/missing pieces, and the reasoning behind the ranking. If the ranking actually changed, open ONE PR for PRIORITIES.md: \`git switch -c codex/architect-$ISSUE_NUM\`, \`git push -u origin codex/architect-$ISSUE_NUM\`, \`gh pr create --base master --label codex --title \"<title>\" --body \"<summary, Closes #$ISSUE_NUM>\"\`, then \`gh pr merge --squash --auto --delete-branch\`. If the queue is already accurate and correctly ranked, do NOT open a PR — just close this issue (\`gh issue close $ISSUE_NUM\`). Do NOT make breaking public-API or architectural changes yourself — surface those in the assessment as notes for the human, never as auto-merged changes. Do not use the make_pr tool (it is a no-op stub)."
@@ -1,4 +1,4 @@
-name: "Loop: Builder (Generator)"
+name: Continuous Improvement

 # Durable backbone for the autonomous improvement loop
 # (see internal/docs/CONTINUOUS_IMPROVEMENT.md).
@@ -1,4 +1,4 @@
-name: "Loop: DevRel"
+name: DevRel Review

 # Daily higher-altitude coherence pass over the PUBLIC surface — README,
 # website (landing + docs), and blog — part of the autonomous loop
@@ -12,22 +12,8 @@ on:
  pull_request:
    branches: ["**"]
  schedule:
-    - cron: "17 * * * *" # hourly, so real-model conformance keeps pace with the dev/loop velocity
+    - cron: "17 6 * * *" # daily, so the world is exercised even without changes
  workflow_dispatch:
-    inputs:
-      providers:
-        description: "Comma-separated providers for live conformance (default: all supported)"
-        required: false
-        default: "anthropic,openai,gemini,groq,mistral,together,atlascloud"
-      harnesses:
-        description: "Comma-separated harnesses for live conformance"
-        required: false
-        default: "agent,universe,agent-flow,plan-delegate,a2a-stream-fallback"
-      require_configured:
-        description: "Fail selected live providers that do not have repository secrets"
-        required: false
-        type: boolean
-        default: false

 jobs:
  harness:
@@ -67,28 +53,11 @@ jobs:
          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
          TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
          ATLASCLOUD_API_KEY: ${{ secrets.ATLASCLOUD_API_KEY }}
-          # Atlas Cloud's default chat model was failing the agent/tool-use
-          # conformance harnesses; run it against a stronger tool-use model.
-          # Override with an Actions variable ATLASCLOUD_MODEL if the exact
-          # catalog id differs (Atlas uses org/model ids).
-          ATLASCLOUD_MODEL: ${{ vars.ATLASCLOUD_MODEL || 'minimaxai/minimax-m3' }}
        run: |
-          PROVIDERS="${{ github.event.inputs.providers || 'anthropic,openai,gemini,groq,mistral,together,atlascloud' }}"
-          HARNESSES="${{ github.event.inputs.harnesses || 'agent,universe,agent-flow,plan-delegate,a2a-stream-fallback' }}"
-          REQUIRE_CONFIGURED="${{ github.event.inputs.require_configured || 'false' }}"
-
-          args=(
-            -providers "$PROVIDERS"
-            -harnesses "$HARNESSES"
-            -summary-json provider-conformance-summary.json
-            -summary-markdown provider-conformance-summary.md
+          go run ./internal/harness/provider-conformance \
+            -summary-json provider-conformance-summary.json \
+            -summary-markdown provider-conformance-summary.md \
            -capabilities-markdown provider-capabilities.md
-          )
-          if [ "$REQUIRE_CONFIGURED" = "true" ]; then
-            args+=( -require-configured )
-          fi
-
-          go run ./internal/harness/provider-conformance "${args[@]}"
      - name: Publish provider conformance summary
        if: always()
        run: |
@@ -1,76 +0,0 @@
-name: "Loop: Release (daily patch)"
-
-# Keeps the installable framework tracking the loop's daily improvements. Once a
-# day, if master has new commits since the latest v6 tag, this cuts the next
-# PATCH release (v6.MINOR.PATCH+1) and pushes the tag — which triggers the
-# existing goreleaser workflow (release.yml, tag-triggered) to build the release,
-# binaries, and images.
-#
-# The tag is pushed with a PAT (CODEX_TRIGGER_TOKEN), NOT the default GITHUB_TOKEN:
-# a tag pushed by GITHUB_TOKEN would not trigger release.yml (Actions blocks that
-# recursion). Minor/major bumps stay with the human (notable / breaking releases).
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "0 23 * * *" # daily 23:00 UTC — captures the day's merges (tunable)
-
-permissions:
-  contents: read
-
-concurrency:
-  group: loop-release
-  cancel-in-progress: false
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # need full history + all tags
-      - name: Cut the next patch release if there are new commits
-        env:
-          RELEASE_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN }}
-          REPO: ${{ github.repository }}
-        run: |
-          if [ -z "$RELEASE_TOKEN" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping."
-            echo "A tag pushed by the default GITHUB_TOKEN would not trigger the"
-            echo "goreleaser workflow, so a user PAT is required to cut releases."
-            exit 0
-          fi
-          git fetch --tags --force
-
-          LATEST=$(git tag --list 'v6.*.*' --sort=-v:refname | head -1)
-          if [ -z "$LATEST" ]; then
-            echo "no v6.x.x tag found — aborting so nothing weird gets tagged."
-            exit 1
-          fi
-          echo "latest release tag: $LATEST"
-
-          COUNT=$(git rev-list --count "$LATEST"..HEAD)
-          echo "commits on HEAD since $LATEST: $COUNT"
-          if [ "$COUNT" -eq 0 ]; then
-            echo "no new commits since $LATEST — no release today."
-            exit 0
-          fi
-
-          # Bump the patch: v6.MINOR.PATCH -> v6.MINOR.(PATCH+1)
-          ver="${LATEST#v}"          # 6.3.10
-          major="${ver%%.*}"         # 6
-          rest="${ver#*.}"           # 3.10
-          minor="${rest%%.*}"        # 3
-          patch="${rest#*.}"         # 10
-          case "$major.$minor.$patch" in
-            [0-9]*.[0-9]*.[0-9]*) ;;
-            *) echo "unexpected tag shape: $LATEST" ; exit 1 ;;
-          esac
-          NEXT="v${major}.${minor}.$((patch + 1))"
-          echo "cutting: $NEXT ($COUNT commits since $LATEST)"
-
-          git config user.name "go-micro release bot"
-          git config user.email "noreply@go-micro.dev"
-          git tag -a "$NEXT" -m "Release $NEXT — automated daily patch ($COUNT commits since $LATEST)"
-          git push "https://x-access-token:${RELEASE_TOKEN}@github.com/${REPO}.git" "$NEXT"
-          echo "Pushed $NEXT. goreleaser (release.yml) will build and publish it."
@@ -1,59 +0,0 @@
-name: "Loop: Triage (Evaluator feedback)"
-
-# Closes the autonomous loop's feedback path: when the live provider-conformance
-# harness fails, dispatch Codex to TRIAGE the failing run and file scoped, deduped
-# issues that the hourly increment loop then fixes — no human in the middle. It
-# only triages the scheduled/manual live run (not every push/PR mock run), dedupes
-# against open issues so hourly repeats don't spam, ignores transient flakes, and
-# ESCALATES anything needing a breaking/architectural change as needs-human rather
-# than auto-building it.
-#
-# Gated on CODEX_TRIGGER_TOKEN like the rest of the loop (Codex ignores comments
-# authored by the github-actions bot).
-#
-# Note: Codex is serial, so this competes with the hourly increment + architect
-# dispatches for the single task slot. If it saturates, lower the harness cadence
-# or gate this to a slower schedule.
-
-on:
-  workflow_run:
-    workflows: ["Harness (E2E)"]
-    types: [completed]
-
-permissions:
-  issues: write
-
-concurrency:
-  group: harness-triage
-  cancel-in-progress: false
-
-jobs:
-  triage:
-    runs-on: ubuntu-latest
-    # Only when the harness actually failed, and only for the scheduled or manual
-    # live run — never the per-push/PR mock run.
-    if: github.event.workflow_run.conclusion == 'failure' && (github.event.workflow_run.event == 'schedule' || github.event.workflow_run.event == 'workflow_dispatch')
-    steps:
-      - name: Open a triage issue and dispatch Codex
-        env:
-          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
-          REPO: ${{ github.repository }}
-          RUN_ID: ${{ github.event.workflow_run.id }}
-          RUN_URL: ${{ github.event.workflow_run.html_url }}
-        run: |
-          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping (Codex ignores Actions-bot comments)."
-            exit 0
-          fi
-          # Ensure the escalation label exists (idempotent).
-          gh label create needs-human --repo "$REPO" --color FBCA04 \
-            --description "Requires a human/architect decision (breaking or architectural)" --force || true
-
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Harness failure triage: run $RUN_ID" \
-            --body "Automated triage of a failed live provider-conformance harness run: $RUN_URL")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened triage issue #$ISSUE_NUM — dispatching Codex."
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
-          "@codex Act as failure triage for the autonomous loop. The live provider-conformance harness failed: $RUN_URL (run id $RUN_ID). Do this, and do NOT change code or open a PR — triage only: (1) Read the failing logs (\`gh run view $RUN_ID --repo $REPO --log-failed\`) and the provider-conformance artifact/summary. (2) Root-cause each DISTINCT failure. (3) DEDUPE against existing work — list open issues (\`gh issue list --repo $REPO --label codex --state open --limit 100\`); if a matching issue already exists for a failure, add a one-line 'recurred in $RUN_URL' comment to it and do NOT open a duplicate. (4) For each genuine, self-contained, CI-verifiable defect that is NOT already tracked, open a scoped issue: \`gh issue create --repo $REPO --label codex --label enhancement --title \"<scoped task>\" --body \"<root cause, scope, acceptance criteria, and the failing run link>\"\` — the hourly increment loop will build it. (5) If a failure is transient/flaky and not a code defect (e.g. a live-model latency timeout or provider outage), note it in a comment and file NOTHING. (6) If a real fix would require a breaking public-API change or an architectural change, do NOT file it as an auto-buildable task — open an issue labeled \`needs-human\` describing it for the architect/human. When finished, close this triage issue (\`gh issue close $ISSUE_NUM\`)."
@@ -6,17 +6,6 @@ Thank you for your interest in contributing to Go Micro! This document provides

 Be respectful, inclusive, and collaborative. We're all here to build great software together.

-## How Go Micro is built
-
-Go Micro is developed by an **autonomous improvement loop** — a planner, a
-generator, and a separate evaluator, running as scheduled GitHub Actions with a
-human setting direction. It's the framework's own thesis (an agent operating a
-system) pointed at itself: an agent harness, built by agents. The full process —
-the planner → generator → evaluator pipeline, the correctness-only merge gate, and
-the guardrails — is documented in
-[`internal/docs/CONTINUOUS_IMPROVEMENT.md`](internal/docs/CONTINUOUS_IMPROVEMENT.md).
-Human contributions follow the same gate: green CI, one concern per PR.
-
 ## Getting Started

 1. Fork the repository
@@ -8,7 +8,7 @@ LDFLAGS = -X $(GIT_IMPORT).BuildDate=$(BUILD_DATE) -X $(GIT_IMPORT).GitCommit=$(
 # GORELEASER_DOCKER_IMAGE = ghcr.io/goreleaser/goreleaser-cross:v1.25.7
 GORELEASER_DOCKER_IMAGE = ghcr.io/goreleaser/goreleaser:latest

-.PHONY: test test-race test-coverage harness provider-conformance-mock provider-conformance lint fmt install-tools proto clean help gorelease-dry-run gorelease-dry-run-docker
+.PHONY: test test-race test-coverage harness provider-conformance lint fmt install-tools proto clean help gorelease-dry-run gorelease-dry-run-docker

 # Default target
 help:
@@ -19,7 +19,6 @@ help:
 	@echo "  make test-coverage - Run tests with coverage"
 	@echo "  make lint          - Run linter"
 	@echo "  make harness       - Run deterministic getting-started and end-to-end harnesses"
-	@echo "  make provider-conformance-mock - Run cross-provider harness with deterministic mock provider"
 	@echo "  make provider-conformance - Run harnesses against configured live providers"
 	@echo "  make fmt           - Format code"
 	@echo "  make install-tools - Install development tools"
@@ -51,12 +50,6 @@ harness:
 	go test ./cmd/micro/cli/new -run TestZeroToOne -count=1
 	./internal/harness/zero-to-hero-ci/run.sh
 	go run ./internal/harness/agent-flow
-	$(MAKE) provider-conformance-mock
-
-# Run the shared provider conformance contract with the deterministic mock
-# provider. This is the no-secret path used by CI and local dogfooding to keep
-# provider-facing agent/tool semantics covered on every machine.
-provider-conformance-mock:
 	go run ./internal/harness/provider-conformance -providers mock

 # Run the same harnesses against every configured live provider. Providers
@@ -1,9 +1,7 @@
-# Go Micro [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/go-micro.dev/v6?tab=doc) [![Go Report Card](https://goreportcard.com/badge/github.com/go-micro/go-micro)](https://goreportcard.com/report/github.com/go-micro/go-micro) [![Discord](https://img.shields.io/badge/Discord-join-5865F2?logo=discord&logoColor=white&style=flat-square)](https://discord.gg/G8Gk5j3uXr)
+# Go Micro [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/go-micro.dev/v6?tab=doc) [![Go Report Card](https://goreportcard.com/badge/github.com/go-micro/go-micro)](https://goreportcard.com/report/github.com/go-micro/go-micro)

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

-**Community:** questions, ideas, or just want to build alongside us? [Join the Discord](https://discord.gg/G8Gk5j3uXr).
-
 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.
@@ -16,7 +14,7 @@ Go Micro gives you the harness as Go code. Build an agent and it gets a model, m
 &nbsp;&nbsp;
 <a href="https://go-micro.dev/blog/8"><img src="https://www.atlascloud.ai/logo.svg" height="26" /></a>

-**Want to support Go Micro and see your logo here?** [Become a sponsor](https://discord.gg/G8Gk5j3uXr) — reach out on Discord.
+**Want to support Go Micro and see your logo here?** [Become a sponsor](https://discord.gg/WeMU5AGxD) — reach out on Discord.

 ## Commercial Support

@@ -67,7 +65,7 @@ curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
 ```

 This scaffold → run → call path is covered by the no-secret CI harness. To run
-the same local contract (including the [0→hero services → agents → workflows path](internal/website/docs/guides/zero-to-hero.md),
+the same local contract (including the 0→hero services → agents → workflows path,
 chat/inspect CLI boundaries, and deploy dry-run), use:

 ```bash
@@ -403,8 +401,8 @@ Swap providers with a single import — same interface everywhere:
 | Google Gemini | `gemini-2.5-flash` |
 | Groq | `llama-3.3-70b-versatile` |
 | Mistral | `mistral-large-latest` |
-| Together AI | `meta-llama/Llama-3.3-70B-Instruct-Turbo` |
-| Atlas Cloud | `deepseek-ai/DeepSeek-V3-0324` |
+| Together AI | `Llama-3.3-70B-Instruct-Turbo` |
+| Atlas Cloud | `llama-3.3-70b` |

 ```go
 m := ai.New("anthropic", ai.WithAPIKey(key))
@@ -425,7 +423,6 @@ See [all examples](examples/README.md).

 - [Getting Started](internal/website/docs/getting-started.md)
 - [AI Integration](internal/website/docs/ai-integration.md)
- [0→hero Reference](internal/website/docs/guides/zero-to-hero.md)
 - [Agents and Workflows](internal/website/docs/guides/agents-and-workflows.md)
 - [Agent Design](internal/docs/AGENT_DESIGN.md)
 - [Plan & Delegate](internal/website/docs/guides/plan-delegate.md)
@@ -66,7 +66,7 @@ hosted service, enterprise tier, or venture funding. See
 ## Contributing & feedback

 Pick an item, open an issue to discuss the approach, and submit a PR. Or join the
-[Discord](https://discord.gg/G8Gk5j3uXr). Include tests, run `make test` and
+[Discord](https://discord.gg/WeMU5AGxD). Include tests, run `make test` and
 `make lint`.

 ## Version support
@@ -174,6 +174,6 @@ We currently do not offer a bug bounty program, but we greatly appreciate respon

 For security questions that are not vulnerabilities, please:
 - Open a discussion: https://github.com/micro/go-micro/discussions
- Join Discord: https://discord.gg/G8Gk5j3uXr
+- Join Discord: https://discord.gg/WeMU5AGxD
 - Email: support@go-micro.dev

@@ -1,102 +0,0 @@
-package agent
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/gateway/a2a"
-)
-
-func TestA2AStreamUsesAgentChatPathWithTools(t *testing.T) {
-	var sawTool bool
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			t.Fatal("model was not wired with agent tool handler")
-		}
-		result := opts.ToolHandler(ctx, ai.ToolCall{
-			ID:    "call-1",
-			Name:  "echo",
-			Input: map[string]any{"value": "a2a-stream"},
-		})
-		if !strings.Contains(result.Content, "a2a-stream-ok") {
-			t.Fatalf("tool result = %q, want marker", result.Content)
-		}
-		return &ai.Response{Answer: "streamed " + result.Content}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("stream-agent"), WithTool("echo", "echo text", nil, func(ctx context.Context, input map[string]any) (string, error) {
-		sawTool = true
-		if info, ok := ai.RunInfoFrom(ctx); !ok || info.RunID == "" || info.Agent != "stream-agent" {
-			t.Fatalf("RunInfo = %+v ok=%v, want stream-agent run", info, ok)
-		}
-		if input["value"] != "a2a-stream" {
-			t.Fatalf("tool input = %+v, want a2a-stream", input)
-		}
-		return "a2a-stream-ok", nil
-	}))
-	h := a2a.NewAgentStreamHandler(
-		a2a.Card("stream-agent", "http://example.invalid/stream-agent", "", nil),
-		func(ctx context.Context, text string) (string, error) {
-			resp, err := a.Ask(ctx, text)
-			if err != nil {
-				return "", err
-			}
-			return resp.Reply, nil
-		},
-		a.streamAskAI,
-	)
-
-	body := []byte(`{"jsonrpc":"2.0","id":1,"method":"message/stream","params":{"message":{"role":"user","parts":[{"kind":"text","text":"run stream tool"}],"kind":"message"}}}`)
-	req := httptest.NewRequest(http.MethodPost, "/", bytes.NewReader(body))
-	rr := httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-
-	if !sawTool {
-		t.Fatal("A2A stream did not execute the agent tool path")
-	}
-	if ct := rr.Result().Header.Get("Content-Type"); !strings.HasPrefix(ct, "text/event-stream") {
-		t.Fatalf("content-type = %q, want text/event-stream", ct)
-	}
-	if !strings.Contains(rr.Body.String(), "a2a-stream-ok") {
-		t.Fatalf("stream body missing tool marker: %s", rr.Body.String())
-	}
-
-	var final struct {
-		Result struct {
-			Status struct {
-				State string `json:"state"`
-			} `json:"status"`
-			Artifacts []struct {
-				Parts []struct {
-					Text string `json:"text"`
-				} `json:"parts"`
-			} `json:"artifacts"`
-		} `json:"result"`
-		Error any `json:"error"`
-	}
-	for _, line := range strings.Split(strings.TrimSpace(rr.Body.String()), "\n") {
-		line = strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(line), "data: "))
-		if line == "" {
-			continue
-		}
-		if err := json.Unmarshal([]byte(line), &final); err != nil {
-			t.Fatalf("decode event %q: %v", line, err)
-		}
-	}
-	if final.Error != nil {
-		t.Fatalf("final event error: %+v", final.Error)
-	}
-	if final.Result.Status.State != "completed" {
-		t.Fatalf("final state = %q, want completed", final.Result.Status.State)
-	}
-	if len(final.Result.Artifacts) != 1 || len(final.Result.Artifacts[0].Parts) != 1 || !strings.Contains(final.Result.Artifacts[0].Parts[0].Text, "a2a-stream-ok") {
-		t.Fatalf("final artifacts = %+v, want tool marker", final.Result.Artifacts)
-	}
-}
@@ -19,7 +19,6 @@ import (
 	"net/http"
 	"strings"
 	"sync"
-	"time"

 	"github.com/google/uuid"
 	pb "go-micro.dev/v6/agent/proto"
@@ -178,9 +177,7 @@ func (a *agentImpl) setupWithToolHandler(handler ai.ToolHandler) {
 	case a.ephemeral:
 		a.mem = NewInMemory(a.opts.HistoryLimit)
 	case a.opts.MemoryCompaction.MaxMessages > 0:
-		a.mem = NewCompactingMemoryWithOptions(a.stateStore(), "history", a.opts.MemoryCompaction)
-	case a.opts.MemoryRetrievalLimit > 0:
-		a.mem = NewRetrievalMemory(a.stateStore(), "history", a.opts.MemoryRetrievalLimit)
+		a.mem = NewCompactingMemory(a.stateStore(), "history", a.opts.MemoryCompaction.MaxMessages, a.opts.MemoryCompaction.KeepRecent)
 	default:
 		a.mem = NewMemory(a.stateStore(), "history", a.opts.HistoryLimit)
 	}
@@ -274,9 +271,6 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		return nil, err
 	}
 	ctx, endRun := a.startRun(ctx, message)
-	if existing != nil {
-		a.recordTimelineEvent(ctx, RunEvent{Time: time.Now(), RunID: runID, ParentID: parentRunID, Agent: a.opts.Name, Kind: "resume", Name: run.State.Stage})
-	}
 	defer func() { endRun(err) }()

 	messages := a.mem.Messages()
@@ -300,15 +294,12 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		Backoff:     a.opts.ModelRetryBackoff,
 	})
 	if err != nil {
-		run.Status = agentRunFailureStatus(err)
+		run.Status = "failed"
+		run.Steps[0].Status = "failed"
+		run.Steps[0].Error = err.Error()
 		if a.currentRun != nil {
 			run.Steps = a.currentRun.Steps
 		}
-		if len(run.Steps) == 0 {
-			run.Steps = []flow.StepRecord{{Name: agentAskStep}}
-		}
-		run.Steps[0].Status = run.Status
-		run.Steps[0].Error = err.Error()
 		_ = a.saveRun(ctx, run)
 		return nil, err
 	}
@@ -329,19 +320,6 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		return nil, fmt.Errorf("agent run %s paused for approval: %s", run.ID, a.pause.Message)
 	}

-	if len(resp.ToolCalls) == 0 {
-		if calls, answer, ok := a.executeTextToolCalls(ctx, resp.Reply, toolList); ok {
-			resp.ToolCalls = calls
-			if resp.Answer == "" {
-				resp.Answer = answer
-			}
-			trimmedReply := strings.TrimSpace(resp.Reply)
-			if strings.HasPrefix(trimmedReply, "{") || strings.HasPrefix(trimmedReply, "[") || strings.HasPrefix(trimmedReply, "```") {
-				resp.Reply = ""
-			}
-		}
-	}
-
 	if resp.Reply != "" {
 		a.mem.Add("assistant", resp.Reply)
 	}
@@ -441,7 +419,7 @@ func (a *agentImpl) Run() error {
 				return "", err
 			}
 			return resp.Reply, nil
-		}, a.streamAskAI)
+		}, a.Stream)
 		go func() {
 			if err := http.ListenAndServe(a.opts.A2AAddress, handler); err != nil {
 				fmt.Printf("agent %s A2A server: %v\n", a.opts.Name, err)
@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
-	"time"

 	"go-micro.dev/v6/ai"
 	codecBytes "go-micro.dev/v6/codec/bytes"
@@ -122,7 +121,6 @@ func (a *agentImpl) toolHandler() ai.ToolHandler {
 	// so the result runs plan → step → loop → approve → checkpoint → base.
 	h := a.baseHandler()
 	h = a.toolTimeoutWrap(h)
-	h = a.toolRetryWrap(h)
 	h = a.checkpointToolWrap(h)
 	h = a.approveWrap(h)
 	h = a.loopWrap(h)
@@ -166,99 +164,6 @@ func (a *agentImpl) toolTimeoutWrap(next ai.ToolHandler) ai.ToolHandler {
 	}
 }

-// toolRetryWrap retries transient tool failures with bounded backoff. It is
-// opt-in because tools can have side effects; guardrail refusals and caller
-// cancellation are never retried.
-func (a *agentImpl) toolRetryWrap(next ai.ToolHandler) ai.ToolHandler {
-	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		maxAttempts := a.opts.ToolMaxAttempts
-		if maxAttempts <= 0 {
-			maxAttempts = 1
-		}
-
-		var res ai.ToolResult
-		for attempt := 1; attempt <= maxAttempts; attempt++ {
-			if err := ctx.Err(); err != nil {
-				return errResult(call.ID, err.Error())
-			}
-			res = next(ctx, call)
-			if !retryableToolResult(res) || attempt == maxAttempts || ctx.Err() != nil {
-				return annotateToolAttempts(res, attempt)
-			}
-
-			t := time.NewTimer(toolRetryBackoff(attempt, a.opts.ToolRetryBackoff))
-			select {
-			case <-ctx.Done():
-				if !t.Stop() {
-					<-t.C
-				}
-				return errResult(call.ID, ctx.Err().Error())
-			case <-t.C:
-			}
-		}
-		return annotateToolAttempts(res, maxAttempts)
-	}
-}
-
-func retryableToolResult(res ai.ToolResult) bool {
-	if res.Refused != "" {
-		return false
-	}
-	msg := toolErrorMessage(res)
-	if msg == "" {
-		return false
-	}
-	return ai.IsTransientError(fmt.Errorf("%s", msg))
-}
-
-func toolErrorMessage(res ai.ToolResult) string {
-	if m, ok := res.Value.(map[string]string); ok {
-		return m["error"]
-	}
-	if m, ok := res.Value.(map[string]any); ok {
-		if v, ok := m["error"].(string); ok {
-			return v
-		}
-	}
-	var decoded map[string]string
-	if err := json.Unmarshal([]byte(res.Content), &decoded); err == nil {
-		return decoded["error"]
-	}
-	return ""
-}
-
-func annotateToolAttempts(res ai.ToolResult, attempts int) ai.ToolResult {
-	if attempts <= 1 {
-		return res
-	}
-	res.Attempts = attempts
-	if m, ok := res.Value.(map[string]string); ok {
-		cp := map[string]any{}
-		for k, v := range m {
-			cp[k] = v
-		}
-		cp["attempts"] = attempts
-		res.Value = cp
-		if b, err := json.Marshal(cp); err == nil {
-			res.Content = string(b)
-		}
-	}
-	return res
-}
-
-func toolRetryBackoff(attempt int, base time.Duration) time.Duration {
-	if base <= 0 {
-		base = 200 * time.Millisecond
-	}
-	if shift := attempt - 1; shift > 0 {
-		base <<= shift
-	}
-	if base > 30*time.Second {
-		return 30 * time.Second
-	}
-	return base
-}
-
 // 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 {
@@ -433,7 +338,6 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) ai.Too
 		ModelCallTimeout(a.opts.ModelTimeout),
 		ModelRetry(a.opts.ModelMaxAttempts, a.opts.ModelRetryBackoff),
 		ToolCallTimeout(a.opts.ToolTimeout),
-		ToolRetry(a.opts.ToolMaxAttempts, a.opts.ToolRetryBackoff),
 		TraceProvider(a.opts.TraceProvider),
 	)
 	// Record lineage so the sub-agent's tool calls carry this run as parent.
@@ -49,12 +49,6 @@ func (a *agentImpl) saveRun(ctx context.Context, run flow.Run) error {
 	if err := a.opts.Checkpoint.Save(ctx, run); err != nil {
 		return fmt.Errorf("agent %s checkpoint save: %w", a.opts.Name, err)
 	}
-	if info, ok := ai.RunInfoFrom(ctx); ok {
-		a.recordTimelineEvent(ctx, RunEvent{
-			Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent,
-			Kind: "checkpoint", Name: run.State.Stage, Status: run.Status,
-		})
-	}
 	return nil
 }

@@ -171,26 +165,13 @@ func (a *agentImpl) pending(ctx context.Context) ([]flow.Run, error) {

 func terminalAgentRunStatus(status string) bool {
 	switch status {
-	case "done", "canceled", "timeout", "rate_limited", "expired":
+	case "done", "canceled", "expired":
 		return true
 	default:
 		return false
 	}
 }

-func agentRunFailureStatus(err error) string {
-	switch ai.ClassifyError(err) {
-	case ai.ErrorKindCanceled:
-		return "canceled"
-	case ai.ErrorKindTimeout:
-		return "timeout"
-	case ai.ErrorKindRateLimited:
-		return "rate_limited"
-	default:
-		return "failed"
-	}
-}
-
 func (a *agentImpl) checkpointToolWrap(next ai.ToolHandler) ai.ToolHandler {
 	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
 		if a.opts.Checkpoint == nil || a.currentRun == nil {
@@ -102,75 +102,6 @@ func TestResumeFailedCheckpointDoesNotReplayCompletedTool(t *testing.T) {
 	}
 }

-func TestResumeFailedCheckpointAfterFreshAgentRestart(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "restart-resume-agent")
-	toolRuns := 0
-	modelCalls := 0
-	failFirst := true
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		modelCalls++
-		if opts.ToolHandler != nil {
-			res := opts.ToolHandler(ctx, ai.ToolCall{ID: "call-1", Name: "external.provision", Input: map[string]any{"service": "api"}})
-			if res.Content != "provisioned" {
-				t.Fatalf("tool result = %q, want provisioned", res.Content)
-			}
-		}
-		if failFirst {
-			failFirst = false
-			return nil, errors.New("process stopped after tool checkpoint")
-		}
-		return &ai.Response{Reply: "resumed after restart"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	newAgent := func() *agentImpl {
-		return newTestAgent(Name("restart-resume-agent"), WithCheckpoint(cp),
-			WithTool("external.provision", "provision service once", nil, func(context.Context, map[string]any) (string, error) {
-				toolRuns++
-				return "provisioned", nil
-			}))
-	}
-
-	first := newAgent()
-	_, err := first.Ask(ctx, "provision api")
-	if err == nil {
-		t.Fatal("Ask succeeded, want simulated process stop")
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions after failed Ask = %d, want 1", toolRuns)
-	}
-	runs, err := Pending(ctx, first)
-	if err != nil {
-		t.Fatalf("Pending before restart: %v", err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("Pending before restart returned %d runs, want 1", len(runs))
-	}
-
-	restarted := newAgent()
-	resp, err := Resume(ctx, restarted, runs[0].ID)
-	if err != nil {
-		t.Fatalf("Resume after restart: %v", err)
-	}
-	if resp.Reply != "resumed after restart" || resp.RunID != runs[0].ID {
-		t.Fatalf("response = %#v, want resumed reply on original run id", resp)
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions after restart resume = %d, want checkpointed tool not replayed", toolRuns)
-	}
-	if modelCalls != 2 {
-		t.Fatalf("model calls = %d, want initial call plus resumed call", modelCalls)
-	}
-	loaded, ok, err := cp.Load(ctx, runs[0].ID)
-	if err != nil || !ok {
-		t.Fatalf("Load resumed run ok=%v err=%v", ok, err)
-	}
-	if loaded.Status != "done" || loaded.ParentID != runs[0].ParentID {
-		t.Fatalf("loaded run status/parent = %s/%s, want done/%s", loaded.Status, loaded.ParentID, runs[0].ParentID)
-	}
-}
-
 func TestResumeFailedCheckpointDoesNotDuplicateCompactedMemory(t *testing.T) {
 	ctx := context.Background()
 	st := store.NewMemoryStore()
@@ -171,50 +171,3 @@ func TestAgentProviderConformanceFakeError(t *testing.T) {
 		t.Fatalf("Ask error = %v, want conformance provider failure", err)
 	}
 }
-
-func TestAgentExecutesProviderTextToolCallFallback(t *testing.T) {
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			return nil, errors.New("missing tool handler")
-		}
-		return &ai.Response{
-			Reply: `{"name":"conformance_echo","input":{"value":"agent-conformance"}}`,
-		}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	var sawTool bool
-	a := New(
-		Name("conformance-text-tool"),
-		Provider("fake"),
-		WithRegistry(registry.NewMemoryRegistry()),
-		WithStore(store.NewMemoryStore()),
-		WithMemory(NewInMemory(4)),
-		WithTool("conformance_echo", "Echo a conformance value.", map[string]any{
-			"value": map[string]any{"type": "string"},
-		}, func(ctx context.Context, input map[string]any) (string, error) {
-			sawTool = true
-			if input["value"] != "agent-conformance" {
-				return "", fmt.Errorf("unexpected value %v", input["value"])
-			}
-			return `{"marker":"agent-conformance-ok"}`, nil
-		}),
-	)
-
-	resp, err := a.Ask(context.Background(), "Run the text tool call fallback.")
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if !sawTool {
-		t.Fatal("text tool call fallback did not execute the tool")
-	}
-	if len(resp.ToolCalls) != 1 || resp.ToolCalls[0].Name != "conformance_echo" {
-		t.Fatalf("ToolCalls = %+v, want conformance_echo", resp.ToolCalls)
-	}
-	if !strings.Contains(resp.Reply, "agent-conformance-ok") {
-		t.Fatalf("Reply = %q, want tool result marker", resp.Reply)
-	}
-	if strings.Contains(resp.Reply, `"name":"conformance_echo"`) {
-		t.Fatalf("Reply = %q, want tool result instead of raw JSON", resp.Reply)
-	}
-}
@@ -24,12 +24,6 @@ type Memory interface {
 	Clear()
 }

-// MemorySummaryFunc turns older conversation messages into a compact
-// replacement message for active context. It is called while the default
-// memory is locked, so implementations should be deterministic and avoid
-// calling back into the same memory instance.
-type MemorySummaryFunc func([]ai.Message) ai.Message
-
 // MemoryCompaction configures deterministic, store-backed context compaction
 // for the default memory implementation. When the retained conversation grows
 // past MaxMessages, older turns are collapsed into a summary message while the
@@ -37,7 +31,6 @@ type MemorySummaryFunc func([]ai.Message) ai.Message
 type MemoryCompaction struct {
 	MaxMessages int
 	KeepRecent  int
-	Summarize   MemorySummaryFunc
 }

 // MemoryRecall is implemented by memory backends that can retrieve durable
@@ -56,29 +49,11 @@ func NewMemory(s store.Store, key string, limit int) Memory {
 	return m
 }

-// NewRetrievalMemory returns store-backed memory that keeps a bounded active
-// conversation and archives every turn for retrieval. It is useful when callers
-// want relevant durable recall without summary compaction in the active context.
-// A nil store or empty key keeps only the active in-process buffer.
-func NewRetrievalMemory(s store.Store, key string, activeLimit int) Memory {
-	m := &storeMemory{store: s, key: key, hist: ai.NewHistory(activeLimit), retrieveAll: true}
-	m.load()
-	return m
-}
-
 // NewCompactingMemory returns store-backed memory with explicit compaction and
 // retrieval controls. It keeps all messages in the backing store, compacts older
 // turns into a deterministic summary when the conversation exceeds maxMessages,
 // and lets callers recall relevant prior turns with Recall.
 func NewCompactingMemory(s store.Store, key string, maxMessages, keepRecent int) Memory {
-	return NewCompactingMemoryWithOptions(s, key, MemoryCompaction{MaxMessages: maxMessages, KeepRecent: keepRecent})
-}
-
-// NewCompactingMemoryWithOptions returns store-backed memory configured with
-// explicit compaction options, including an optional summarization hook.
-func NewCompactingMemoryWithOptions(s store.Store, key string, compaction MemoryCompaction) Memory {
-	maxMessages := compaction.MaxMessages
-	keepRecent := compaction.KeepRecent
 	if keepRecent <= 0 {
 		keepRecent = maxMessages / 2
 	}
@@ -94,7 +69,6 @@ func NewCompactingMemoryWithOptions(s store.Store, key string, compaction Memory
 		compaction: MemoryCompaction{
 			MaxMessages: maxMessages,
 			KeepRecent:  keepRecent,
-			Summarize:   compaction.Summarize,
 		},
 	}
 	m.load()
@@ -110,20 +84,16 @@ func NewInMemory(limit int) Memory {
 // storeMemory is the default Memory: an ai.History buffer optionally
 // persisted to a store.
 type storeMemory struct {
-	mu          sync.Mutex
-	store       store.Store
-	key         string
-	hist        *ai.History
-	compaction  MemoryCompaction
-	archive     []ai.Message
-	retrieveAll bool
+	mu         sync.Mutex
+	store      store.Store
+	key        string
+	hist       *ai.History
+	compaction MemoryCompaction
+	archive    []ai.Message
 }

 func (m *storeMemory) Add(role, content string) {
 	m.mu.Lock()
-	if m.retrieveAll {
-		m.archive = append(m.archive, ai.Message{Role: role, Content: content})
-	}
 	m.hist.Add(role, content)
 	m.mu.Unlock()
 	m.compact()
@@ -147,8 +117,6 @@ func (m *storeMemory) Clear() {
 // Recall returns archived messages whose content contains words from query.
 // It is deterministic and provider-neutral: no embeddings or model calls are
 // required, but semantic/vector stores can replace Memory for richer retrieval.
-// When created with NewRetrievalMemory the archive contains every persisted
-// turn; when created with NewCompactingMemory it contains compacted older turns.
 func (m *storeMemory) Recall(query string, limit int) []ai.Message {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -202,9 +170,6 @@ func (m *storeMemory) load() {
 	}
 	m.mu.Lock()
 	m.archive = state.Archive
-	if m.retrieveAll && len(m.archive) == 0 {
-		m.archive = append(m.archive, state.Messages...)
-	}
 	for _, msg := range state.Messages {
 		m.hist.Add(msg.Role, msg.Content)
 	}
@@ -248,13 +213,9 @@ func (m *storeMemory) compact() {
 	older := msgs[:cut]
 	recent := msgs[cut:]
 	m.archive = append(m.archive, older...)
-	summarize := m.compaction.Summarize
-	if summarize == nil {
-		summarize = defaultMemorySummary
-	}
-	summary := summarize(older)
-	if summary.Role == "" {
-		summary.Role = "system"
+	summary := ai.Message{
+		Role:    "system",
+		Content: fmt.Sprintf("Conversation memory summary: %s", summarizeMessages(older)),
 	}
 	m.hist.Reset()
 	m.hist.Add(summary.Role, summary.Content)
@@ -263,13 +224,6 @@ func (m *storeMemory) compact() {
 	}
 }

-func defaultMemorySummary(msgs []ai.Message) ai.Message {
-	return ai.Message{
-		Role:    "system",
-		Content: fmt.Sprintf("Conversation memory summary: %s", summarizeMessages(msgs)),
-	}
-}
-
 func summarizeMessages(msgs []ai.Message) string {
 	var b strings.Builder
 	for i, msg := range msgs {
@@ -3,11 +3,9 @@ package agent
 import (
 	"context"
 	"errors"
-	"strconv"
 	"strings"
 	"testing"

-	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/registry"
 	"go-micro.dev/v6/store"
 )
@@ -64,49 +62,6 @@ func TestWithMemoryUsed(t *testing.T) {
 	}
 }

-func TestRetrievalMemoryArchivesAllTurnsAndRanksRelevant(t *testing.T) {
-	st := store.NewMemoryStore()
-	m := NewRetrievalMemory(st, "agent/retrieval/history", 2)
-	m.Add("user", "alpha budget is 42")
-	m.Add("assistant", "noted")
-	m.Add("user", "beta owner is lee")
-	m.Add("assistant", "tracked")
-	m.Add("user", "alpha owner is sam")
-
-	if got := len(m.Messages()); got != 2 {
-		t.Fatalf("active messages = %d, want bounded history of 2", got)
-	}
-
-	recall, ok := m.(MemoryRecall)
-	if !ok {
-		t.Fatal("retrieval memory should support recall")
-	}
-	recalled := recall.Recall("alpha budget", 2)
-	if len(recalled) == 0 {
-		t.Fatal("expected relevant recalled turns")
-	}
-	if got := recalled[0].Content.(string); !strings.Contains(got, "alpha budget is 42") {
-		t.Fatalf("top recall = %q, want archived alpha budget turn", got)
-	}
-}
-
-func TestRetrievalMemoryPersistsArchiveAcrossReload(t *testing.T) {
-	st := store.NewMemoryStore()
-	m := NewRetrievalMemory(st, "agent/retrieval/reload", 1)
-	m.Add("user", "alpha budget is 42")
-	m.Add("assistant", "noted")
-	m.Add("user", "beta budget is 7")
-
-	reloaded := NewRetrievalMemory(st, "agent/retrieval/reload", 1)
-	recalled := reloaded.(MemoryRecall).Recall("alpha budget", 1)
-	if len(recalled) != 1 {
-		t.Fatalf("recalled %d messages, want 1", len(recalled))
-	}
-	if got := recalled[0].Content.(string); !strings.Contains(got, "alpha budget is 42") {
-		t.Fatalf("reloaded recall = %q, want alpha budget", got)
-	}
-}
-
 func TestCompactingMemoryRecallRanksSpecificMatches(t *testing.T) {
 	m := NewCompactingMemory(store.NewMemoryStore(), "agent/rank/history", 3, 1).(MemoryRecall)
 	writer := m.(Memory)
@@ -147,36 +102,6 @@ func TestCompactingMemoryArchivePersistsAndReloads(t *testing.T) {
 	}
 }

-func TestCompactingMemoryUsesCustomSummarizerAndReloadsRecall(t *testing.T) {
-	st := store.NewMemoryStore()
-	m := NewCompactingMemoryWithOptions(st, "agent/custom/history", MemoryCompaction{
-		MaxMessages: 3,
-		KeepRecent:  1,
-		Summarize: func(msgs []ai.Message) ai.Message {
-			return ai.Message{Role: "system", Content: "custom summary count=" + strconv.Itoa(len(msgs))}
-		},
-	})
-	m.Add("user", "alpha budget is 42")
-	m.Add("assistant", "noted")
-	m.Add("user", "beta budget is 7")
-	m.Add("assistant", "noted")
-
-	msgs := m.Messages()
-	if len(msgs) == 0 || msgs[0].Content != "custom summary count=3" {
-		t.Fatalf("summary = %#v, want custom summarizer output", msgs)
-	}
-
-	reloaded := NewCompactingMemoryWithOptions(st, "agent/custom/history", MemoryCompaction{MaxMessages: 3, KeepRecent: 1})
-	recall := reloaded.(MemoryRecall)
-	recalled := recall.Recall("alpha budget", 1)
-	if len(recalled) != 1 {
-		t.Fatalf("recalled %d messages, want 1", len(recalled))
-	}
-	if got := recalled[0].Content.(string); !strings.Contains(got, "alpha budget is 42") {
-		t.Fatalf("reloaded recall = %q, want alpha budget", got)
-	}
-}
-
 // A custom tool is offered to the model and dispatched to its handler.
 func TestWithToolExposedAndDispatched(t *testing.T) {
 	var got map[string]any
@@ -60,19 +60,10 @@ type Options struct {
 	// applied before custom tools, delegate, and service RPC calls so context
 	// deadlines propagate consistently through the agent loop.
 	ToolTimeout time.Duration
-	// ToolMaxAttempts bounds tool execution attempts including the first call.
-	// Default 1; retries are opt-in because tools can have side effects.
-	ToolMaxAttempts int
-	// ToolRetryBackoff is the base delay between transient tool failures.
-	ToolRetryBackoff time.Duration

 	// Memory is the agent's conversation memory. Nil = the default
 	// store-backed memory (durable across restarts).
 	Memory Memory
-	// MemoryRetrievalLimit enables retrieval-backed default memory without
-	// compaction. The active conversation stays bounded to this many messages
-	// while every turn is archived for deterministic recall.
-	MemoryRetrievalLimit int
 	// MemoryCompaction enables deterministic compaction/retrieval on the
 	// default store-backed memory. Custom Memory implementations can expose
 	// retrieval by implementing MemoryRecall.
@@ -126,8 +117,6 @@ func newOptions(opts ...Option) Options {
 		ModelMaxAttempts:  1, // retries opt-in via ModelRetry (see field doc)
 		ModelRetryBackoff: 100 * time.Millisecond,
 		ToolTimeout:       30 * time.Second,
-		ToolMaxAttempts:   1,
-		ToolRetryBackoff:  100 * time.Millisecond,
 		// On by default and lenient: identical repeated calls are a
 		// no-progress loop, never useful. Set LoopLimit(0) to disable.
 		LoopLimit: 3,
@@ -236,16 +225,6 @@ func ModelRetry(maxAttempts int, backoff time.Duration) Option {
 	}
 }

-// ToolRetry sets the tool retry budget and backoff for transient failures.
-// Attempts include the first call. Retries are opt-in because tools may have
-// side effects; keep handlers idempotent before enabling this.
-func ToolRetry(maxAttempts int, backoff time.Duration) Option {
-	return func(o *Options) {
-		o.ToolMaxAttempts = maxAttempts
-		o.ToolRetryBackoff = backoff
-	}
-}
-
 // WithA2A makes Run serve the agent over the A2A protocol on addr (e.g.
 // ":4000"), so other agents can reach it directly by URL without a
 // separate gateway. The agent stays a normal go-micro service as well;
@@ -261,40 +240,19 @@ func WithMemory(m Memory) Option {
 	return func(o *Options) { o.Memory = m }
 }

-// RetrievalMemory enables deterministic, store-backed retrieval memory for
-// the default agent memory without compaction. Active context is capped at
-// activeLimit messages while every turn is archived in the store for Recall.
-func RetrievalMemory(activeLimit int) Option {
-	return func(o *Options) {
-		o.MemoryRetrievalLimit = activeLimit
-		if o.MemoryRecallLimit == 0 {
-			o.MemoryRecallLimit = 5
-		}
-	}
-}
-
 // CompactMemory enables deterministic, store-backed memory compaction for the
 // default agent memory. Older turns are summarized once active context exceeds
 // maxMessages, keepRecent newest turns remain verbatim, and recalled archived
 // turns are injected into matching future asks.
 func CompactMemory(maxMessages, keepRecent int) Option {
 	return func(o *Options) {
-		o.MemoryCompaction.MaxMessages = maxMessages
-		o.MemoryCompaction.KeepRecent = keepRecent
+		o.MemoryCompaction = MemoryCompaction{MaxMessages: maxMessages, KeepRecent: keepRecent}
 		if o.MemoryRecallLimit == 0 {
 			o.MemoryRecallLimit = 5
 		}
 	}
 }

-// MemorySummarizer sets the deterministic summarization hook used by the
-// default compacting memory. It is optional; without it, compacted memory uses
-// a provider-neutral text summary. The hook receives the older messages being
-// removed from active context and returns the replacement summary message.
-func MemorySummarizer(fn MemorySummaryFunc) Option {
-	return func(o *Options) { o.MemoryCompaction.Summarize = fn }
-}
-
 // MemoryRecallLimit sets how many archived turns a memory backend may inject
 // into a model request for the current Ask. Use 0 to disable retrieval.
 func MemoryRecallLimit(n int) Option {
@@ -22,29 +22,23 @@ const (
 	spanNameModelCall = "agent.model.call"
 	spanNameToolCall  = "agent.tool.call"

-	AttrRunID            = "agent.run.id"
-	AttrParentRunID      = "agent.run.parent_id"
-	AttrAgentName        = "agent.name"
-	AttrProvider         = "agent.model.provider"
-	AttrModel            = "agent.model.name"
-	AttrLatencyMS        = "agent.latency_ms"
-	AttrInputTokens      = "agent.tokens.input"
-	AttrOutputTokens     = "agent.tokens.output"
-	AttrTotalTokens      = "agent.tokens.total"
-	AttrAttempt          = "agent.model.attempt"
-	AttrMaxAttempts      = "agent.model.max_attempts"
-	AttrToolName         = "agent.tool.name"
-	AttrDelegate         = "agent.delegate"
-	AttrGuardrailBlock   = "agent.guardrail.block"
-	AttrRefusal          = "agent.refusal"
-	AttrInputChars       = "agent.input.chars"
-	AttrErrorKind        = "agent.error.kind"
-	AttrCheckpointStatus = "agent.checkpoint.status"
-	AttrCheckpointStage  = "agent.checkpoint.stage"
-	AttrFlowName         = "agent.flow.name"
-	AttrFlowStep         = "agent.flow.step"
-	AttrDispatch         = "agent.dispatch"
-	AttrTrigger          = "agent.trigger"
+	AttrRunID          = "agent.run.id"
+	AttrParentRunID    = "agent.run.parent_id"
+	AttrAgentName      = "agent.name"
+	AttrProvider       = "agent.model.provider"
+	AttrModel          = "agent.model.name"
+	AttrLatencyMS      = "agent.latency_ms"
+	AttrInputTokens    = "agent.tokens.input"
+	AttrOutputTokens   = "agent.tokens.output"
+	AttrTotalTokens    = "agent.tokens.total"
+	AttrAttempt        = "agent.model.attempt"
+	AttrMaxAttempts    = "agent.model.max_attempts"
+	AttrToolName       = "agent.tool.name"
+	AttrDelegate       = "agent.delegate"
+	AttrGuardrailBlock = "agent.guardrail.block"
+	AttrRefusal        = "agent.refusal"
+	AttrInputChars     = "agent.input.chars"
+	AttrErrorKind      = "agent.error.kind"
 )

 type RunEvent struct {
@@ -63,7 +57,6 @@ type RunEvent struct {
 	LatencyMS   int64     `json:"latency_ms,omitempty"`
 	Tokens      Usage     `json:"tokens,omitempty"`
 	Refused     string    `json:"refused,omitempty"`
-	Status      string    `json:"status,omitempty"`
 	Error       string    `json:"error,omitempty"`
 	ErrorKind   string    `json:"error_kind,omitempty"`
 	InputChars  int       `json:"input_chars,omitempty"`
@@ -128,12 +121,8 @@ func (a *agentImpl) startRun(ctx context.Context, message string) (context.Conte
 		}
 	}

-	attrs := appendRunInfoAttributes([]attribute.KeyValue{
-		attribute.String(AttrRunID, info.RunID),
-		attribute.String(AttrParentRunID, info.ParentID),
-		attribute.String(AttrAgentName, info.Agent),
-	}, info)
-	ctx, span := a.tracer().Start(ctx, spanNameRun, trace.WithSpanKind(trace.SpanKindInternal), trace.WithAttributes(attrs...))
+	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)))
 	a.recordSpanEvent(span, runEvent)
 	return ctx, func(err error) {
 		latency := time.Since(start).Milliseconds()
@@ -179,17 +168,16 @@ func (m *tracedModel) Generate(ctx context.Context, req *ai.Request, opts ...ai.
 		return resp, err
 	}

-	attrs := appendRunInfoAttributes([]attribute.KeyValue{
+	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),
-	}, info)
-	ctx, span := m.a.tracer().Start(ctx, spanNameModelCall, trace.WithAttributes(attrs...))
+	))
 	resp, err := m.Model.Generate(ctx, req, opts...)
 	dur := time.Since(start).Milliseconds()
-	attrs = []attribute.KeyValue{attribute.Int64(AttrLatencyMS, dur)}
+	attrs := []attribute.KeyValue{attribute.Int64(AttrLatencyMS, dur)}
 	if info.Attempt > 0 {
 		attrs = append(attrs, attribute.Int(AttrAttempt, info.Attempt))
 	}
@@ -301,15 +289,6 @@ func classifyToolError(err string) string {
 	}
 }

-func (a *agentImpl) recordTimelineEvent(ctx context.Context, e RunEvent) {
-	span := trace.SpanFromContext(ctx)
-	if span.SpanContext().IsValid() {
-		a.recordSpanEvent(span, e)
-		return
-	}
-	a.recordRunEvent(e)
-}
-
 func (a *agentImpl) recordSpanEvent(span trace.Span, e RunEvent) {
 	if sc := span.SpanContext(); sc.IsValid() {
 		e.TraceID = sc.TraceID().String()
@@ -358,30 +337,6 @@ func runEventAttributes(e RunEvent) []attribute.KeyValue {
 	if e.ErrorKind != "" {
 		attrs = append(attrs, attribute.String(AttrErrorKind, e.ErrorKind))
 	}
-	if e.Kind == "checkpoint" {
-		if e.Status != "" {
-			attrs = append(attrs, attribute.String(AttrCheckpointStatus, e.Status))
-		}
-		if e.Name != "" {
-			attrs = append(attrs, attribute.String(AttrCheckpointStage, e.Name))
-		}
-	}
-	return attrs
-}
-
-func appendRunInfoAttributes(attrs []attribute.KeyValue, info ai.RunInfo) []attribute.KeyValue {
-	if info.Flow != "" {
-		attrs = append(attrs, attribute.String(AttrFlowName, info.Flow))
-	}
-	if info.Step != "" {
-		attrs = append(attrs, attribute.String(AttrFlowStep, info.Step))
-	}
-	if info.Dispatch != "" {
-		attrs = append(attrs, attribute.String(AttrDispatch, info.Dispatch))
-	}
-	if info.Trigger != "" {
-		attrs = append(attrs, attribute.String(AttrTrigger, info.Trigger))
-	}
 	return attrs
 }

@@ -10,7 +10,6 @@ import (
 	"time"

 	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/flow"
 	"go-micro.dev/v6/store"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
@@ -389,74 +388,6 @@ func TestAgentRunTimelineRecordsModelAndToolWithoutTraceProvider(t *testing.T) {
 	}
 }

-func TestAgentCheckpointAndResumeTimelineEvents(t *testing.T) {
-	exp := tracetest.NewInMemoryExporter()
-	tp := trace.NewTracerProvider(trace.WithSyncer(exp))
-	st := store.NewMemoryStore()
-	cp := flow.StoreCheckpoint(st, "resume-otel-agent")
-	first := true
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if first {
-			first = false
-			return nil, errors.New("temporary provider failure")
-		}
-		return &ai.Response{Reply: "resumed"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("resume-otel-agent"), WithStore(st), WithCheckpoint(cp), TraceProvider(tp))
-	_, err := a.Ask(context.Background(), "resume me")
-	if err == nil {
-		t.Fatal("Ask succeeded, want simulated failure")
-	}
-
-	runs, err := cp.List(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("checkpointed runs = %d, want 1", len(runs))
-	}
-	resp, err := Resume(context.Background(), a, runs[0].ID)
-	if err != nil {
-		t.Fatalf("Resume: %v", err)
-	}
-	if resp.Reply != "resumed" {
-		t.Fatalf("reply = %q, want resumed", resp.Reply)
-	}
-
-	events, err := LoadRunEvents(st, "resume-otel-agent", runs[0].ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	seen := map[string]bool{"checkpoint": false, "resume": false}
-	for _, e := range events {
-		if _, ok := seen[e.Kind]; ok {
-			seen[e.Kind] = true
-		}
-	}
-	for kind, ok := range seen {
-		if !ok {
-			t.Fatalf("missing %s event in timeline: %#v", kind, events)
-		}
-	}
-
-	var resumeSpanEvent bool
-	for _, s := range exp.GetSpans().Snapshots() {
-		if s.Name() != spanNameRun {
-			continue
-		}
-		for _, e := range s.Events() {
-			if e.Name == "agent.resume" {
-				resumeSpanEvent = true
-			}
-		}
-	}
-	if !resumeSpanEvent {
-		t.Fatal("run span missing agent.resume event")
-	}
-}
-
 func TestLoadRunEventsSortsTimelineKeys(t *testing.T) {
 	st := store.NewMemoryStore()
 	scoped := store.Scope(st, "agent", "runner")
@@ -8,8 +8,6 @@ import (
 	"time"

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

 func TestAskCancellationAbortsPromptly(t *testing.T) {
@@ -131,101 +129,3 @@ func TestToolCallTimeoutPropagatesDeadlineToCustomTool(t *testing.T) {
 		t.Fatalf("tool call took %s, want bounded timeout", elapsed)
 	}
 }
-
-func TestAskCheckpointRecordsTerminalOperationalFailureStatus(t *testing.T) {
-	tests := []struct {
-		name string
-		err  error
-		want string
-	}{
-		{name: "canceled", err: context.Canceled, want: "canceled"},
-		{name: "timeout", err: context.DeadlineExceeded, want: "timeout"},
-		{name: "rate limited", err: testStatusError{code: 429}, want: "rate_limited"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cp := flow.StoreCheckpoint(store.NewMemoryStore(), "terminal-"+strings.ReplaceAll(tt.name, " ", "-"))
-			fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-				return nil, tt.err
-			}
-			defer func() { fakeGen = nil }()
-
-			a := newTestAgent(Name("terminal-"+strings.ReplaceAll(tt.name, " ", "-")), WithCheckpoint(cp))
-			_, err := a.Ask(context.Background(), "fail safely")
-			if err == nil {
-				t.Fatal("Ask succeeded, want failure")
-			}
-
-			runs, err := cp.List(context.Background())
-			if err != nil {
-				t.Fatalf("List: %v", err)
-			}
-			if len(runs) != 1 {
-				t.Fatalf("checkpointed runs = %d, want 1", len(runs))
-			}
-			if runs[0].Status != tt.want {
-				t.Fatalf("run status = %q, want %q", runs[0].Status, tt.want)
-			}
-			if len(runs[0].Steps) == 0 || runs[0].Steps[0].Status != tt.want {
-				t.Fatalf("step status = %#v, want %q", runs[0].Steps, tt.want)
-			}
-			if pending, err := Pending(context.Background(), a); err != nil || len(pending) != 0 {
-				t.Fatalf("Pending = %#v, %v; want no terminal run", pending, err)
-			}
-		})
-	}
-}
-
-type testStatusError struct {
-	code int
-}
-
-func (e testStatusError) Error() string { return "provider status error" }
-
-func (e testStatusError) StatusCode() int { return e.code }
-
-func TestToolRetryRetriesTransientToolErrorsThenSucceeds(t *testing.T) {
-	attempts := 0
-	a := newTestAgent(
-		Name("tool-retry-success"),
-		ToolRetry(3, time.Millisecond),
-		WithTool("flaky", "flaky tool", nil, func(context.Context, map[string]any) (string, error) {
-			attempts++
-			if attempts < 3 {
-				return "", context.DeadlineExceeded
-			}
-			return "ok", nil
-		}),
-	)
-
-	content := toolContent(a.toolHandler(), "flaky", nil)
-	if content != "ok" {
-		t.Fatalf("tool result = %q, want ok", content)
-	}
-	if attempts != 3 {
-		t.Fatalf("attempts = %d, want 3", attempts)
-	}
-}
-
-func TestToolRetryDoesNotRetryGuardrailRefusals(t *testing.T) {
-	attempts := 0
-	a := newTestAgent(
-		Name("tool-retry-refusal"),
-		MaxSteps(1),
-		ToolRetry(3, time.Millisecond),
-		WithTool("counted", "counted tool", nil, func(context.Context, map[string]any) (string, error) {
-			attempts++
-			return "ok", nil
-		}),
-	)
-	h := a.toolHandler()
-	_ = toolContent(h, "counted", nil)
-	content := toolContent(h, "counted", nil)
-	if !strings.Contains(content, "step limit reached") {
-		t.Fatalf("tool result = %q, want step-limit refusal", content)
-	}
-	if attempts != 1 {
-		t.Fatalf("attempts = %d, want only the allowed tool call to execute", attempts)
-	}
-}
@@ -181,43 +181,6 @@ func (a *agentImpl) resumeWithStreamEvents(ctx context.Context, runID string, ev
 	return a.askLocked(ctx, run.ID, string(run.State.Data), run.ParentID, &run, false)
 }

-type agentStreamAdapter struct {
-	stream AgentStream
-}
-
-func (s *agentStreamAdapter) Recv() (*ai.Response, error) {
-	for {
-		event, err := s.stream.Recv()
-		if err != nil {
-			return nil, err
-		}
-		if event == nil {
-			continue
-		}
-		switch event.Type {
-		case StreamEventToken:
-			if event.Token == "" {
-				continue
-			}
-			return &ai.Response{Reply: event.Token}, nil
-		case StreamEventDone:
-			return nil, io.EOF
-		}
-	}
-}
-
-func (s *agentStreamAdapter) Close() error {
-	return s.stream.Close()
-}
-
-func (a *agentImpl) streamAskAI(ctx context.Context, message string) (ai.Stream, error) {
-	stream, err := a.StreamAsk(ctx, message)
-	if err != nil {
-		return nil, err
-	}
-	return &agentStreamAdapter{stream: stream}, nil
-}
-
 type agentStream struct {
 	events <-chan *StreamEvent
 	done   <-chan struct{}
@@ -1,141 +0,0 @@
-package agent
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"regexp"
-	"strings"
-
-	"go-micro.dev/v6/ai"
-)
-
-var fencedJSONBlock = regexp.MustCompile("(?s)```(?:json)?\\s*(.*?)\\s*```")
-
-type textToolCall struct {
-	ID        string         `json:"id"`
-	Name      string         `json:"name"`
-	Tool      string         `json:"tool"`
-	Input     map[string]any `json:"input"`
-	Arguments map[string]any `json:"arguments"`
-}
-
-// executeTextToolCalls is a compatibility fallback for providers that return a
-// tool call as text JSON instead of a structured tool_calls field. It only runs
-// calls whose names match the tools offered to the model, so ordinary JSON
-// answers are left untouched.
-func (a *agentImpl) executeTextToolCalls(ctx context.Context, reply string, tools []ai.Tool) ([]ai.ToolCall, string, bool) {
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) == 0 {
-		return nil, "", false
-	}
-
-	handler := a.toolHandler()
-	results := make([]string, 0, len(calls))
-	for i := range calls {
-		result := handler(ctx, calls[i])
-		calls[i].Result = result.Content
-		if result.Refused != "" {
-			calls[i].Error = result.Refused
-		}
-		if result.Content != "" {
-			results = append(results, result.Content)
-		}
-	}
-	return calls, strings.Join(results, "\n"), true
-}
-
-func parseTextToolCalls(text string, tools []ai.Tool) []ai.ToolCall {
-	allowed := map[string]bool{}
-	for _, tool := range tools {
-		allowed[tool.Name] = true
-		if tool.OriginalName != "" {
-			allowed[tool.OriginalName] = true
-		}
-	}
-	if len(allowed) == 0 {
-		return nil
-	}
-
-	for _, candidate := range jsonCandidates(text) {
-		if calls := decodeTextToolCalls(candidate, allowed); len(calls) > 0 {
-			return calls
-		}
-	}
-	return nil
-}
-
-func jsonCandidates(text string) []string {
-	trimmed := strings.TrimSpace(text)
-	var out []string
-	if trimmed != "" {
-		out = append(out, trimmed)
-	}
-	for _, match := range fencedJSONBlock.FindAllStringSubmatch(text, -1) {
-		if len(match) > 1 {
-			out = append(out, strings.TrimSpace(match[1]))
-		}
-	}
-	if start, end := strings.IndexAny(text, "[{"), strings.LastIndexAny(text, "]}"); start >= 0 && end > start {
-		out = append(out, strings.TrimSpace(text[start:end+1]))
-	}
-	return out
-}
-
-func decodeTextToolCalls(candidate string, allowed map[string]bool) []ai.ToolCall {
-	var root any
-	if err := json.Unmarshal([]byte(candidate), &root); err != nil {
-		return nil
-	}
-	return collectTextToolCalls(root, allowed)
-}
-
-func collectTextToolCalls(v any, allowed map[string]bool) []ai.ToolCall {
-	switch x := v.(type) {
-	case []any:
-		var out []ai.ToolCall
-		for _, item := range x {
-			out = append(out, collectTextToolCalls(item, allowed)...)
-		}
-		return out
-	case map[string]any:
-		if nested, ok := firstNestedToolCalls(x); ok {
-			return collectTextToolCalls(nested, allowed)
-		}
-		call := mapToTextToolCall(x)
-		name := call.Name
-		if name == "" {
-			name = call.Tool
-		}
-		input := call.Input
-		if input == nil {
-			input = call.Arguments
-		}
-		if name == "" || !allowed[name] || input == nil {
-			return nil
-		}
-		id := call.ID
-		if id == "" {
-			id = fmt.Sprintf("text-call-%s", strings.ReplaceAll(name, ".", "_"))
-		}
-		return []ai.ToolCall{{ID: id, Name: name, Input: input}}
-	default:
-		return nil
-	}
-}
-
-func firstNestedToolCalls(m map[string]any) (any, bool) {
-	for _, key := range []string{"tool_calls", "toolCalls", "calls"} {
-		if v, ok := m[key]; ok {
-			return v, true
-		}
-	}
-	return nil, false
-}
-
-func mapToTextToolCall(m map[string]any) textToolCall {
-	b, _ := json.Marshal(m)
-	var call textToolCall
-	_ = json.Unmarshal(b, &call)
-	return call
-}
@@ -27,7 +27,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"os"
 	"strings"
 	"time"

@@ -57,14 +56,7 @@ func NewProvider(opts ...ai.Option) *Provider {
 	options := ai.NewOptions(opts...)

 	if options.Model == "" {
-		// Allow the chat model to be selected via the ATLASCLOUD_MODEL env var
-		// (e.g. to run CI conformance against a stronger tool-use model) without
-		// a code change; fall back to a sensible default otherwise.
-		if m := os.Getenv("ATLASCLOUD_MODEL"); m != "" {
-			options.Model = m
-		} else {
-			options.Model = "deepseek-ai/DeepSeek-V3-0324"
-		}
+		options.Model = "deepseek-ai/DeepSeek-V3-0324"
 	}
 	if options.BaseURL == "" {
 		options.BaseURL = "https://api.atlascloud.ai"
@@ -93,10 +93,9 @@ func (c ToolCall) Scan(v any) error {

 // ToolResult represents the result of a tool execution
 type ToolResult struct {
-	ID       string // Tool call ID (for correlation)
-	Value    any    // Structured result (optional)
-	Content  string // Tool execution result (JSON string), shown to the model
-	Attempts int    `json:"attempts,omitempty"` // Tool execution attempts, set when retried.
+	ID      string // Tool call ID (for correlation)
+	Value   any    // Structured result (optional)
+	Content string // Tool execution result (JSON string), shown to the model
 	// Refused names the reason a guardrail blocked the call before it ran
 	// ("max_steps", "loop", "approval"); empty when the call executed. A
 	// tool wrapper can switch on it to build reliability tooling — react to
@@ -122,16 +121,13 @@ const (
 // tell which provider attempt produced the call and whether it is part of a
 // retry budget. They are zero when no model-attempt context is known.
 type RunInfo struct {
-	RunID                string // correlation id for this agent or flow run
-	ParentID             string // the run that delegated to this one, if any
-	Agent                string // the agent's name
-	Flow                 string // the flow's name, when the call is part of a workflow
-	Step                 string // the flow step currently executing, when known
-	Attempt              int    // current model Generate attempt, starting at 1 when known
-	MaxAttempts          int    // configured model Generate attempt budget when known
-	VerificationFeedback string // feedback from the previous failed verifier attempt, when retrying a flow step
-	Dispatch             string // how the run was dispatched (direct, broker, schedule, resume) when known
-	Trigger              string // external trigger or schedule label that started the run, when known
+	RunID       string // correlation id for this agent or flow run
+	ParentID    string // the run that delegated to this one, if any
+	Agent       string // the agent's name
+	Flow        string // the flow's name, when the call is part of a workflow
+	Step        string // the flow step currently executing, when known
+	Attempt     int    // current model Generate attempt, starting at 1 when known
+	MaxAttempts int    // configured model Generate attempt budget when known
 }

 type runInfoKey struct{}
@@ -7,7 +7,6 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
-	"os"
 	"reflect"
 	"strings"
 	"testing"
@@ -151,109 +150,6 @@ func TestStreamProvidersCloseCancelsInFlightRequest(t *testing.T) {
 	}
 }

-func TestStreamProvidersPropagateProviderErrors(t *testing.T) {
-	for _, provider := range conformingStreamProviders(t) {
-		provider := provider
-		t.Run(provider, func(t *testing.T) {
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				http.Error(w, "upstream quota exhausted", http.StatusTooManyRequests)
-			}))
-			defer ts.Close()
-
-			stream, err := ai.New(provider, ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL)).Stream(context.Background(), &ai.Request{Prompt: "Hello"})
-			if err == nil {
-				_ = stream.Close()
-				t.Fatal("Stream returned nil error for provider failure")
-			}
-			if !strings.Contains(err.Error(), "429") || !strings.Contains(err.Error(), "upstream quota exhausted") {
-				t.Fatalf("Stream error = %v, want provider status and body", err)
-			}
-			if strings.Contains(err.Error(), "test-key") {
-				t.Fatal("provider error leaked API key")
-			}
-		})
-	}
-}
-
-func TestStreamProvidersHonorCanceledContextBeforeRequest(t *testing.T) {
-	for _, provider := range conformingStreamProviders(t) {
-		provider := provider
-		t.Run(provider, func(t *testing.T) {
-			var sawRequest bool
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				sawRequest = true
-				http.Error(w, "unexpected request", http.StatusInternalServerError)
-			}))
-			defer ts.Close()
-
-			ctx, cancel := context.WithCancel(context.Background())
-			cancel()
-			stream, err := ai.New(provider, ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL)).Stream(ctx, &ai.Request{Prompt: "Hello"})
-			if err == nil {
-				_ = stream.Close()
-				t.Fatal("Stream returned nil error for canceled context")
-			}
-			if !errors.Is(err, context.Canceled) {
-				t.Fatalf("Stream error = %v, want context.Canceled", err)
-			}
-			if sawRequest {
-				t.Fatal("provider sent request after context was already canceled")
-			}
-		})
-	}
-}
-
-func TestConfiguredProviderStreamsSkipWithoutCredentials(t *testing.T) {
-	for _, tc := range []struct {
-		provider string
-		keyEnv   string
-		modelEnv string
-	}{
-		{provider: "openai", keyEnv: "OPENAI_API_KEY", modelEnv: "OPENAI_MODEL"},
-		{provider: "groq", keyEnv: "GROQ_API_KEY", modelEnv: "GROQ_MODEL"},
-		{provider: "mistral", keyEnv: "MISTRAL_API_KEY", modelEnv: "MISTRAL_MODEL"},
-		{provider: "together", keyEnv: "TOGETHER_API_KEY", modelEnv: "TOGETHER_MODEL"},
-		{provider: "atlascloud", keyEnv: "ATLASCLOUD_API_KEY", modelEnv: "ATLASCLOUD_MODEL"},
-	} {
-		tc := tc
-		t.Run(tc.provider, func(t *testing.T) {
-			key := os.Getenv(tc.keyEnv)
-			if key == "" {
-				t.Skipf("%s not set; skipping configured provider stream check", tc.keyEnv)
-			}
-
-			opts := []ai.Option{ai.WithAPIKey(key)}
-			if model := os.Getenv(tc.modelEnv); model != "" {
-				opts = append(opts, ai.WithModel(model))
-			}
-			stream, err := ai.New(tc.provider, opts...).Stream(context.Background(), &ai.Request{Prompt: "Reply with exactly: ok"})
-			if err != nil {
-				t.Fatalf("Stream returned error: %v", err)
-			}
-			defer stream.Close()
-
-			deadline := time.After(30 * time.Second)
-			for {
-				select {
-				case <-deadline:
-					t.Fatal("timed out waiting for provider stream chunk")
-				default:
-				}
-				chunk, err := stream.Recv()
-				if err != nil {
-					if errors.Is(err, io.EOF) {
-						t.Fatal("provider stream ended without content")
-					}
-					t.Fatalf("Recv returned error: %v", err)
-				}
-				if chunk.Reply != "" {
-					return
-				}
-			}
-		})
-	}
-}
-
 func TestUnsupportedProvidersReturnStreamingUnsupportedAndStayUnregistered(t *testing.T) {
 	for _, provider := range []string{"anthropic", "gemini"} {
 		provider := provider
@@ -324,4 +324,4 @@ Apache 2.0 - See [LICENSE](../../LICENSE) for details.
 ## Support

 - GitHub Discussions: https://github.com/micro/go-micro/discussions
- Discord: https://discord.gg/G8Gk5j3uXr
+- Discord: https://discord.gg/WeMU5AGxD
@@ -102,4 +102,4 @@ pytest tests/integration/ -v
 ## Questions?

 - GitHub Discussions: https://github.com/micro/go-micro/discussions
- Discord: https://discord.gg/G8Gk5j3uXr
+- Discord: https://discord.gg/WeMU5AGxD
@@ -370,4 +370,4 @@ Apache 2.0 - See [LICENSE](../../LICENSE) for details.
 ## Support

 - GitHub Discussions: https://github.com/micro/go-micro/discussions
- Discord: https://discord.gg/G8Gk5j3uXr
+- Discord: https://discord.gg/WeMU5AGxD
@@ -18,19 +18,6 @@ run and `micro.AgentResume` continues it from the saved checkpoint. The final
 `tool executions: 1` line is the important bit: the reservation tool was not
 called a second time during resume.

-## When to use this instead of a durable flow
-
-Use a durable flow when the path is known ahead of time: ordered service calls,
-retries, timers, compensation, and a precise resume stage such as `reserve` or
-`charge`. Use a checkpointed agent run when the path is open-ended and the model
-may choose tools dynamically, but completed tool side effects still must not be
-replayed after a crash or provider failure.
-
-They compose: keep deterministic business process in `flow-durable`, then hand
-off the judgment-heavy step to a checkpointed agent when the workflow needs
-model-directed tool use. Both use the same `Checkpoint` backend, so inspection
-and recovery can share one run-history store.
-
 In a service, use the same pattern at startup:

 ```go
@@ -1,48 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"strings"
-	"testing"
-)
-
-func TestDurableAgentExampleResumesWithoutReplayingTool(t *testing.T) {
-	out := captureStdout(t, main)
-	if !strings.Contains(out, "simulated process interruption after checkpointed tool call") {
-		t.Fatalf("example output %q did not show the initial interrupted run", out)
-	}
-	if !strings.Contains(out, "resumed reply: sku-123 is reserved; no duplicate reservation was made") {
-		t.Fatalf("example output %q did not show the resumed response", out)
-	}
-	if !strings.Contains(out, "tool executions: 1") {
-		t.Fatalf("example output %q did not prove the tool was not replayed", out)
-	}
-}
-
-func captureStdout(t *testing.T, fn func()) string {
-	t.Helper()
-
-	old := os.Stdout
-	r, w, err := os.Pipe()
-	if err != nil {
-		t.Fatalf("pipe stdout: %v", err)
-	}
-	os.Stdout = w
-
-	var buf bytes.Buffer
-	done := make(chan struct{})
-	go func() {
-		_, _ = io.Copy(&buf, r)
-		close(done)
-	}()
-
-	fn()
-
-	_ = w.Close()
-	os.Stdout = old
-	<-done
-	_ = r.Close()
-	return buf.String()
-}
@@ -7,7 +7,6 @@ import (

 	"go-micro.dev/v6/client"
 	codecbytes "go-micro.dev/v6/codec/bytes"
-	"go-micro.dev/v6/store"
 )

 // fakeClient embeds the default client (so NewRequest works) and
@@ -66,65 +65,3 @@ func TestExecuteDispatchesToAgent(t *testing.T) {
 		t.Errorf("rendered prompt = %q, want %q", results[0].Prompt, "welcome bob")
 	}
 }
-
-// A caller-owned schedule can trigger an agent workflow without a human chat
-// prompt and still leave the normal flow run metadata behind for inspection.
-func TestScheduledAgentRunHarnessContract(t *testing.T) {
-	ctx := context.Background()
-	cp := StoreCheckpoint(store.NewMemoryStore(), "scheduled-contract")
-	f := New("scheduled-contract",
-		Trigger("schedule.daily"),
-		WithCheckpoint(cp),
-		Steps(Step{Name: "summarize", Run: Dispatch("ops-agent")}),
-	)
-
-	var parentID string
-	f.client = &fakeClient{
-		Client: client.DefaultClient,
-		callFn: func(req client.Request, rsp interface{}) error {
-			if req.Service() != "ops-agent" || req.Endpoint() != "Agent.Chat" {
-				t.Fatalf("dispatched to %s.%s, want ops-agent.Agent.Chat", 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"]
-			if body["message"] != "run unattended daily ops review" {
-				t.Fatalf("message = %q, want scheduled payload", body["message"])
-			}
-			frame := rsp.(*codecbytes.Frame)
-			frame.Data = []byte(`{"reply":"review queued","agent":"ops-agent","parent_id":"` + parentID + `"}`)
-			return nil
-		},
-	}
-
-	if err := Scheduled(f, "run unattended daily ops review").Tick(ctx); err != nil {
-		t.Fatalf("scheduled tick: %v", err)
-	}
-	if parentID == "" {
-		t.Fatal("dispatch did not receive the scheduled flow run id as parent_id")
-	}
-
-	runs, err := cp.List(ctx)
-	if err != nil {
-		t.Fatalf("list scheduled runs: %v", err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("got %d runs, want 1", len(runs))
-	}
-	run := runs[0]
-	if run.ID != parentID {
-		t.Fatalf("run ID = %q, parent_id = %q", run.ID, parentID)
-	}
-	if run.Flow != "scheduled-contract" || run.Status != "done" {
-		t.Fatalf("run = %+v, want scheduled-contract done", run)
-	}
-	if got := run.State.String(); got != "review queued" {
-		t.Fatalf("run result = %q, want agent reply", got)
-	}
-	if len(run.Steps) != 1 || run.Steps[0].Name != "summarize" || run.Steps[0].Status != "done" {
-		t.Fatalf("steps = %+v, want summarize done", run.Steps)
-	}
-}
@@ -76,7 +76,6 @@ type Result struct {
 	Answer    string    `json:"answer,omitempty"`
 	ToolCalls []string  `json:"tool_calls,omitempty"`
 	Error     string    `json:"error,omitempty"`
-	ErrorKind string    `json:"error_kind,omitempty"`
 	Timestamp time.Time `json:"timestamp"`
 	Duration  float64   `json:"duration_seconds"`
 }
@@ -142,8 +141,7 @@ func (f *Flow) Register(reg registry.Registry, br broker.Broker, cl client.Clien
 	if f.opts.TriggerTopic != "" {
 		sub, err := br.Subscribe(f.opts.TriggerTopic, func(p broker.Event) error {
 			data := string(p.Message().Body)
-			ctx := ai.WithRunInfo(context.Background(), ai.RunInfo{Dispatch: "broker", Trigger: f.opts.TriggerTopic})
-			if err := f.Execute(ctx, data); err != nil {
+			if err := f.Execute(context.Background(), data); err != nil {
 				f.log.Logf(logger.ErrorLevel, "Flow %s failed: %v", f.name, err)
 			}
 			return nil
@@ -224,10 +222,7 @@ func (f *Flow) Execute(ctx context.Context, data string) error {
 	}

 	runID := uuid.New().String()
-	info, _ := ai.RunInfoFrom(ctx)
-	info.RunID = runID
-	info.Flow = f.name
-	ctx = ai.WithRunInfo(ctx, info)
+	ctx = ai.WithRunInfo(ctx, ai.RunInfo{RunID: runID, Flow: f.name})

 	start := time.Now()

@@ -251,7 +246,6 @@ func (f *Flow) Execute(ctx context.Context, data string) error {
 		result.Duration = time.Since(start).Seconds()
 		if err != nil {
 			result.Error = err.Error()
-			result.ErrorKind = string(ai.ClassifyError(err))
 			f.record(result)
 			return err
 		}
@@ -267,7 +261,6 @@ func (f *Flow) Execute(ctx context.Context, data string) error {
 	if err != nil {
 		result.Duration = time.Since(start).Seconds()
 		result.Error = err.Error()
-		result.ErrorKind = string(ai.ClassifyError(err))
 		f.record(result)
 		return fmt.Errorf("discover tools: %w", err)
 	}
@@ -281,7 +274,6 @@ func (f *Flow) Execute(ctx context.Context, data string) error {

 	if err != nil {
 		result.Error = err.Error()
-		result.ErrorKind = string(ai.ClassifyError(err))
 		f.record(result)
 		return err
 	}
@@ -16,18 +16,13 @@ const (
 	spanNameFlowRun  = "flow.run"
 	spanNameFlowStep = "flow.step"

-	AttrFlowRunID              = "flow.run.id"
-	AttrFlowParentID           = "flow.run.parent_id"
-	AttrFlowName               = "flow.name"
-	AttrFlowStepName           = "flow.step.name"
-	AttrFlowStatus             = "flow.status"
-	AttrFlowAttempts           = "flow.step.attempts"
-	AttrFlowLatencyMS          = "flow.latency_ms"
-	AttrFlowErrorKind          = "flow.error.kind"
-	AttrFlowVerificationStatus = "flow.verification.status"
-	AttrFlowVerificationNote   = "flow.verification.note"
-	AttrFlowDispatch           = "flow.dispatch"
-	AttrFlowTrigger            = "flow.trigger"
+	AttrFlowRunID     = "flow.run.id"
+	AttrFlowParentID  = "flow.run.parent_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 {
@@ -38,15 +33,12 @@ func (f *Flow) startRunSpan(ctx context.Context, run Run) (context.Context, func
 	if f.opts.TraceProvider == nil {
 		return ctx, func(Run, error) {}
 	}
-	info, _ := ai.RunInfoFrom(ctx)
-	attrs := []attribute.KeyValue{
+	ctx, span := f.tracer().Start(ctx, spanNameFlowRun, trace.WithSpanKind(trace.SpanKindInternal), trace.WithAttributes(
 		attribute.String(AttrFlowRunID, run.ID),
 		attribute.String(AttrFlowParentID, run.ParentID),
 		attribute.String(AttrFlowName, f.name),
 		attribute.String(AttrFlowStatus, run.Status),
-	}
-	attrs = appendRunInfoDispatch(attrs, info)
-	ctx, span := f.tracer().Start(ctx, spanNameFlowRun, trace.WithSpanKind(trace.SpanKindInternal), trace.WithAttributes(attrs...))
+	))
 	start := time.Now()
 	return ctx, func(done Run, err error) {
 		span.SetAttributes(
@@ -55,7 +47,6 @@ func (f *Flow) startRunSpan(ctx context.Context, run Run) (context.Context, func
 		)
 		if err != nil {
 			span.RecordError(err)
-			span.SetAttributes(attribute.String(AttrFlowErrorKind, string(ai.ClassifyError(err))))
 			span.SetStatus(codes.Error, err.Error())
 		} else {
 			span.SetStatus(codes.Ok, "")
@@ -64,51 +55,29 @@ func (f *Flow) startRunSpan(ctx context.Context, run Run) (context.Context, func
 	}
 }

-func (f *Flow) runStepSpan(ctx context.Context, step Step, in State) (State, int, Verification, error) {
+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)
-	attrs := []attribute.KeyValue{
+	ctx, span := f.tracer().Start(ctx, spanNameFlowStep, trace.WithAttributes(
 		attribute.String(AttrFlowRunID, info.RunID),
 		attribute.String(AttrFlowParentID, info.ParentID),
 		attribute.String(AttrFlowName, f.name),
 		attribute.String(AttrFlowStepName, step.Name),
-	}
-	attrs = appendRunInfoDispatch(attrs, info)
-	ctx, span := f.tracer().Start(ctx, spanNameFlowStep, trace.WithAttributes(attrs...))
+	))
 	start := time.Now()
-	out, attempts, verification, err := f.runStep(ctx, step, in)
+	out, attempts, err := f.runStep(ctx, step, in)
 	span.SetAttributes(
 		attribute.Int(AttrFlowAttempts, attempts),
 		attribute.Int64(AttrFlowLatencyMS, time.Since(start).Milliseconds()),
 	)
-	if verification.Passed {
-		span.SetAttributes(attribute.String(AttrFlowVerificationStatus, "passed"))
-	}
-	if verification.Feedback != "" {
-		span.SetAttributes(attribute.String(AttrFlowVerificationNote, verification.Feedback))
-		if !verification.Passed {
-			span.SetAttributes(attribute.String(AttrFlowVerificationStatus, "failed"))
-		}
-	}
 	if err != nil {
 		span.RecordError(err)
-		span.SetAttributes(attribute.String(AttrFlowErrorKind, string(ai.ClassifyError(err))))
 		span.SetStatus(codes.Error, err.Error())
 	} else {
 		span.SetStatus(codes.Ok, "")
 	}
 	span.End()
-	return out, attempts, verification, err
-}
-
-func appendRunInfoDispatch(attrs []attribute.KeyValue, info ai.RunInfo) []attribute.KeyValue {
-	if info.Dispatch != "" {
-		attrs = append(attrs, attribute.String(AttrFlowDispatch, info.Dispatch))
-	}
-	if info.Trigger != "" {
-		attrs = append(attrs, attribute.String(AttrFlowTrigger, info.Trigger))
-	}
-	return attrs
+	return out, attempts, err
 }
@@ -74,29 +74,3 @@ func flowSpanAttributes(attrs []attribute.KeyValue) map[string]string {
 func withTestRunInfo(ctx context.Context, runID string) context.Context {
 	return ai.WithRunInfo(ctx, ai.RunInfo{RunID: runID, Agent: "planner"})
 }
-
-func TestScheduledFlowOpenTelemetryDispatchAttributes(t *testing.T) {
-	exp := tracetest.NewInMemoryExporter()
-	tp := trace.NewTracerProvider(trace.WithSyncer(exp))
-
-	step := Step{Name: "summarize", Run: func(ctx context.Context, in State) (State, error) {
-		in.Data = []byte("queued")
-		return in, nil
-	}}
-	f := New("scheduled-observed", Trigger("schedule.daily"), WithCheckpoint(StoreCheckpoint(store.NewMemoryStore(), "scheduled-observed")), TraceProvider(tp), Steps(step))
-	if err := Scheduled(f, "daily ops review").Tick(context.Background()); err != nil {
-		t.Fatal(err)
-	}
-
-	for _, span := range exp.GetSpans().Snapshots() {
-		if span.Name() != spanNameFlowRun {
-			continue
-		}
-		attrs := flowSpanAttributes(span.Attributes())
-		if attrs[AttrFlowDispatch] != "schedule" || attrs[AttrFlowTrigger] != "schedule.daily" {
-			t.Fatalf("scheduled run span dispatch attributes = %#v", attrs)
-		}
-		return
-	}
-	t.Fatal("flow run span not emitted")
-}
@@ -1,60 +0,0 @@
-package flow
-
-import (
-	"context"
-	"time"
-
-	"go-micro.dev/v6/ai"
-)
-
-// Schedule binds a flow to a recurring work item without introducing a
-// scheduler service. It is a small harness contract: callers own the clock,
-// Go Micro owns turning each tick into the same inspectable flow run used for
-// broker events and direct Execute calls.
-type Schedule struct {
-	flow *Flow
-	data string
-}
-
-// Scheduled returns a deterministic scheduled-run harness for this flow.
-// Tests and event loops can call Tick directly; production processes can wire
-// the same contract to time.Ticker through RunEvery. Each tick calls Execute, so
-// checkpointed run history, parent/run metadata, cancellation, and inspection
-// stay on the normal flow surfaces.
-func Scheduled(f *Flow, data string) Schedule {
-	return Schedule{flow: f, data: data}
-}
-
-// Tick starts one scheduled run immediately and returns when that run finishes.
-func (s Schedule) Tick(ctx context.Context) error {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	info, _ := ai.RunInfoFrom(ctx)
-	info.Dispatch = "schedule"
-	if info.Trigger == "" {
-		info.Trigger = s.flow.opts.TriggerTopic
-	}
-	if info.Trigger == "" {
-		info.Trigger = "schedule"
-	}
-	return s.flow.Execute(ai.WithRunInfo(ctx, info), s.data)
-}
-
-// RunEvery drives scheduled runs from a ticker until ctx is canceled. It does
-// not persist schedule definitions or host a scheduler; it only adapts a caller
-// owned cadence to Tick.
-func (s Schedule) RunEvery(ctx context.Context, interval time.Duration) error {
-	ticker := time.NewTicker(interval)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case <-ticker.C:
-			if err := s.Tick(ctx); err != nil {
-				return err
-			}
-		}
-	}
-}
@@ -52,53 +52,22 @@ func (s State) String() string { return string(s.Data) }
 // returns the next state.
 type StepFunc func(ctx context.Context, in State) (State, error)

-// Verifier grades a step output before the flow advances. Returning
-// Passed=false converts the grade into a retryable VerificationError, so
-// the existing step retry/supervision path can feed Feedback into the next
-// attempt through ai.RunInfo.VerificationFeedback.
-type Verifier func(ctx context.Context, out State) (Verification, error)
-
-// Verification is the verifier's deterministic grade for one step attempt.
-type Verification struct {
-	Passed   bool
-	Feedback string
-}
-
-// VerificationError reports a failed grade. It is returned from runStep so
-// existing retry, checkpoint, and trace paths handle verifier failures the
-// same way they handle step execution failures.
-type VerificationError struct {
-	Step     string
-	Feedback string
-}
-
-func (e *VerificationError) Error() string {
-	if e.Feedback == "" {
-		return fmt.Sprintf("flow: verification failed for step %q", e.Step)
-	}
-	return fmt.Sprintf("flow: verification failed for step %q: %s", e.Step, e.Feedback)
-}
-
-// Step is one unit of a flow — a named action with optional retry and
-// verification hooks. There is one Step kind; the action is the Run func,
-// and the Call/LLM/Agent helpers produce the common ones.
+// Step is one unit of a flow — a named action with an optional retry
+// override. There is one Step kind; the action is the Run func, and the
+// Call/LLM/Agent helpers produce the common ones.
 type Step struct {
-	Name   string
-	Run    StepFunc
-	Retry  int      // per-step override of the flow's retry (0 = use the flow default)
-	Verify Verifier // optional grade; failed grades retry the step with feedback in RunInfo
+	Name  string
+	Run   StepFunc
+	Retry int // per-step override of the flow's retry (0 = use the flow default)
 }

 // StepRecord is the recorded outcome of one step within a run.
 type StepRecord struct {
-	Name               string `json:"name"`
-	Status             string `json:"status"` // pending | in_progress | done | failed
-	Attempts           int    `json:"attempts"`
-	Result             string `json:"result,omitempty"`
-	Error              string `json:"error,omitempty"`
-	ErrorKind          string `json:"error_kind,omitempty"`
-	VerificationStatus string `json:"verification_status,omitempty"` // passed | failed
-	VerificationNote   string `json:"verification_note,omitempty"`
+	Name     string `json:"name"`
+	Status   string `json:"status"` // pending | in_progress | done | failed
+	Attempts int    `json:"attempts"`
+	Result   string `json:"result,omitempty"`
+	Error    string `json:"error,omitempty"`
 }

 // Run is the persisted record of one flow execution — what a Checkpoint
@@ -433,12 +402,7 @@ 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})
-	info, _ := ai.RunInfoFrom(ctx)
-	info.RunID = run.ID
-	info.ParentID = run.ParentID
-	info.Agent = f.name
-	info.Flow = f.name
-	ctx = ai.WithRunInfo(ctx, info)
+	ctx = ai.WithRunInfo(ctx, ai.RunInfo{RunID: run.ID, ParentID: run.ParentID, Agent: f.name, Flow: f.name})
 	ctx, finishSpan := f.startRunSpan(ctx, run)
 	var spanErr error
 	defer func() { finishSpan(run, spanErr) }()
@@ -461,14 +425,12 @@ func (f *Flow) runFrom(ctx context.Context, run Run) (Run, error) {
 			return run, err
 		}

-		out, attempts, verification, err := f.runStepSpan(ctx, step, run.State)
+		out, attempts, err := f.runStepSpan(ctx, step, run.State)
 		run.Steps[i].Attempts = attempts
-		applyVerificationRecord(&run.Steps[i], verification)
 		if err != nil {
 			spanErr = err
 			run.Steps[i].Status = "failed"
 			run.Steps[i].Error = err.Error()
-			run.Steps[i].ErrorKind = string(ai.ClassifyError(err))
 			run.Status = "failed"
 			if saveErr := f.save(ctx, run); saveErr != nil {
 				spanErr = saveErr
@@ -512,65 +474,40 @@ func (f *Flow) runFrom(ctx context.Context, run Run) (Run, error) {
 // runStep runs one step, retrying on error up to the resolved retry count.
 // A step with no Run function is a configuration error, and a canceled run
 // stops retrying immediately rather than burning the rest of its budget.
-func (f *Flow) runStep(ctx context.Context, step Step, in State) (State, int, Verification, error) {
+func (f *Flow) runStep(ctx context.Context, step Step, in State) (State, int, error) {
 	if step.Run == nil {
-		return in, 0, Verification{}, fmt.Errorf("flow: step %q has no Run function", step.Name)
+		return in, 0, fmt.Errorf("flow: step %q has no Run function", step.Name)
 	}
 	retries := f.opts.Retry
 	if step.Retry > 0 {
 		retries = step.Retry
 	}
 	var lastErr error
-	var lastVerification Verification
-	var feedback string
 	for attempt := 1; attempt <= retries+1; attempt++ {
 		// Stop the moment the run's context is canceled or its deadline
 		// passes — a canceled run shouldn't keep retrying, and the context
 		// error is surfaced so callers can detect cancellation upstream.
 		if err := ctx.Err(); err != nil {
-			return in, attempt - 1, lastVerification, err
+			return in, attempt - 1, err
 		}
-		attemptCtx := ctx
 		if info, ok := ai.RunInfoFrom(ctx); ok {
 			info.Step = step.Name
-			info.VerificationFeedback = feedback
-			attemptCtx = ai.WithRunInfo(ctx, info)
-		}
-		out, err := step.Run(attemptCtx, in)
-		if err == nil && step.Verify != nil {
-			lastVerification, err = step.Verify(attemptCtx, out)
-			if err == nil && !lastVerification.Passed {
-				err = &VerificationError{Step: step.Name, Feedback: lastVerification.Feedback}
-			}
+			ctx = ai.WithRunInfo(ctx, info)
 		}
+		out, err := step.Run(ctx, in)
 		if err == nil {
-			return out, attempt, lastVerification, nil
+			return out, attempt, nil
 		}
 		lastErr = err
-		if verr, ok := err.(*VerificationError); ok {
-			feedback = verr.Feedback
-		}
 		if attempt <= retries && f.opts.RetryBackoff > 0 {
 			select {
 			case <-time.After(f.opts.RetryBackoff):
 			case <-ctx.Done():
-				return in, attempt, lastVerification, ctx.Err()
+				return in, attempt, ctx.Err()
 			}
 		}
 	}
-	return in, retries + 1, lastVerification, lastErr
-}
-
-func applyVerificationRecord(record *StepRecord, verification Verification) {
-	if verification.Passed {
-		record.VerificationStatus = "passed"
-	}
-	if verification.Feedback != "" {
-		record.VerificationNote = truncate(verification.Feedback, 200)
-		if !verification.Passed {
-			record.VerificationStatus = "failed"
-		}
-	}
+	return in, retries + 1, lastErr
 }

 func (f *Flow) save(ctx context.Context, run Run) error {
@@ -618,7 +555,6 @@ func resultFromRun(trigger string, run Run) Result {
 		r.ToolCalls = append(r.ToolCalls, s.Name+":"+s.Status)
 		if s.Error != "" {
 			r.Error = s.Error
-			r.ErrorKind = s.ErrorKind
 		}
 	}
 	if run.Status == "done" {
@@ -548,37 +548,3 @@ func TestStateSetScan(t *testing.T) {
 		t.Errorf("round-trip failed: %+v", got)
 	}
 }
-
-func TestFlowFailureRecordsErrorKind(t *testing.T) {
-	cp := StoreCheckpoint(store.NewMemoryStore(), "failure-kind")
-	f := New("failure-kind",
-		WithCheckpoint(cp),
-		Steps(Step{Name: "limited", Run: func(_ context.Context, in State) (State, error) {
-			return in, errors.New("rate limit exceeded")
-		}}),
-	)
-
-	err := f.Execute(context.Background(), "payload")
-	if err == nil {
-		t.Fatal("Execute error = nil, want failure")
-	}
-
-	runs, listErr := cp.List(context.Background())
-	if listErr != nil {
-		t.Fatalf("List: %v", listErr)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("runs = %d, want 1", len(runs))
-	}
-	if got := runs[0].Steps[0].ErrorKind; got != string(ai.ErrorKindRateLimited) {
-		t.Fatalf("step error kind = %q, want %q", got, ai.ErrorKindRateLimited)
-	}
-
-	results := f.Results()
-	if len(results) != 1 {
-		t.Fatalf("results = %d, want 1", len(results))
-	}
-	if got := results[0].ErrorKind; got != string(ai.ErrorKindRateLimited) {
-		t.Fatalf("result error kind = %q, want %q", got, ai.ErrorKindRateLimited)
-	}
-}
@@ -1,100 +0,0 @@
-package flow
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/store"
-)
-
-func TestFlowStepVerificationRetriesWithFeedback(t *testing.T) {
-	var attempts int
-	var feedback []string
-	step := Step{
-		Name:  "draft",
-		Retry: 1,
-		Run: func(ctx context.Context, in State) (State, error) {
-			attempts++
-			info, ok := ai.RunInfoFrom(ctx)
-			if !ok {
-				t.Fatal("RunInfo missing from verified step")
-			}
-			feedback = append(feedback, info.VerificationFeedback)
-			if info.VerificationFeedback == "add evidence" {
-				in.Data = []byte("answer with evidence")
-			} else {
-				in.Data = []byte("answer")
-			}
-			return in, nil
-		},
-		Verify: func(ctx context.Context, out State) (Verification, error) {
-			if out.String() == "answer with evidence" {
-				return Verification{Passed: true, Feedback: "meets rubric"}, nil
-			}
-			return Verification{Feedback: "add evidence"}, nil
-		},
-	}
-
-	cp := StoreCheckpoint(store.NewMemoryStore(), "verified")
-	f := New("verified", WithCheckpoint(cp), Steps(step))
-	if err := f.Execute(context.Background(), "question"); err != nil {
-		t.Fatal(err)
-	}
-	if attempts != 2 {
-		t.Fatalf("attempts = %d, want 2", attempts)
-	}
-	if len(feedback) != 2 || feedback[0] != "" || feedback[1] != "add evidence" {
-		t.Fatalf("feedback = %#v, want empty then verifier feedback", feedback)
-	}
-	runs, err := cp.List(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("runs = %d, want 1", len(runs))
-	}
-	stepRecord := runs[0].Steps[0]
-	if stepRecord.Status != "done" || stepRecord.Attempts != 2 || stepRecord.VerificationStatus != "passed" || stepRecord.VerificationNote != "meets rubric" {
-		t.Fatalf("step record = %#v", stepRecord)
-	}
-}
-
-func TestFlowStepVerificationFailureIsCheckpointed(t *testing.T) {
-	step := Step{
-		Name: "grade",
-		Run: func(ctx context.Context, in State) (State, error) {
-			in.Data = []byte("bad")
-			return in, nil
-		},
-		Verify: func(ctx context.Context, out State) (Verification, error) {
-			return Verification{Feedback: "missing citation"}, nil
-		},
-	}
-
-	cp := StoreCheckpoint(store.NewMemoryStore(), "verified-fail")
-	f := New("verified-fail", WithCheckpoint(cp), Steps(step))
-	err := f.Execute(context.Background(), "question")
-	if err == nil {
-		t.Fatal("Execute succeeded, want verification failure")
-	}
-	var verr *VerificationError
-	if !errors.As(err, &verr) {
-		t.Fatalf("error = %T %v, want VerificationError", err, err)
-	}
-	if verr.Feedback != "missing citation" {
-		t.Fatalf("feedback = %q, want missing citation", verr.Feedback)
-	}
-	runs, listErr := cp.List(context.Background())
-	if listErr != nil {
-		t.Fatal(listErr)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("runs = %d, want 1", len(runs))
-	}
-	stepRecord := runs[0].Steps[0]
-	if runs[0].Status != "failed" || stepRecord.VerificationStatus != "failed" || stepRecord.VerificationNote != "missing citation" {
-		t.Fatalf("run = %#v step = %#v", runs[0], stepRecord)
-	}
-}
@@ -180,8 +180,6 @@ type Provider struct {
 type Capabilities struct {
 	Streaming         bool `json:"streaming"`
 	PushNotifications bool `json:"pushNotifications"`
-	TaskResubscribe   bool `json:"taskResubscribe"`
-	InputRequired     bool `json:"inputRequired"`
 }

 // Skill is a capability advertised on the Agent Card.
@@ -351,7 +349,7 @@ func Card(name, url, description string, services []string) AgentCard {
 		URL:                url,
 		Version:            "1.0.0",
 		ProtocolVersion:    protocolVersion,
-		Capabilities:       Capabilities{Streaming: true, PushNotifications: true, TaskResubscribe: true, InputRequired: true},
+		Capabilities:       Capabilities{Streaming: true, PushNotifications: true},
 		DefaultInputModes:  []string{"text/plain"},
 		DefaultOutputModes: []string{"text/plain"},
 		Skills:             skills,
@@ -91,9 +91,6 @@ func TestAgentCardFromRegistry(t *testing.T) {
 	if card.ProtocolVersion == "" {
 		t.Errorf("card missing protocolVersion: %+v", card)
 	}
-	if !card.Capabilities.TaskResubscribe || !card.Capabilities.InputRequired {
-		t.Errorf("card capabilities = %+v, want task resubscribe and input-required advertised", card.Capabilities)
-	}
 	if got := skillIDs(card.Skills); strings.Join(got, ",") != "task,project" {
 		t.Errorf("skill IDs = %v, want [task project]", got)
 	}
@@ -1,13 +1,11 @@
 package a2a

 import (
-	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"strings"
 	"time"

 	"github.com/google/uuid"
@@ -137,77 +135,6 @@ func (c *Client) SendMessage(ctx context.Context, message Message) (*Task, error
 	return &task, nil
 }

-// Resubscribe reconnects to a retained or active task stream and returns task
-// snapshots as the remote agent emits updates. The returned channel is closed
-// when the task reaches a terminal state or ctx is canceled.
-func (c *Client) Resubscribe(ctx context.Context, taskID string) (<-chan Task, <-chan error) {
-	tasks := make(chan Task, 8)
-	errs := make(chan error, 1)
-	go func() {
-		defer close(tasks)
-		defer close(errs)
-		body, _ := json.Marshal(map[string]any{
-			"jsonrpc": "2.0",
-			"id":      uuid.New().String(),
-			"method":  "tasks/resubscribe",
-			"params":  getParams{ID: taskID},
-		})
-		req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.url, bytes.NewReader(body))
-		if err != nil {
-			errs <- err
-			return
-		}
-		req.Header.Set("Content-Type", "application/json")
-		req.Header.Set("Accept", "text/event-stream")
-		resp, err := c.http.Do(req)
-		if err != nil {
-			errs <- err
-			return
-		}
-		defer resp.Body.Close()
-		if resp.StatusCode != http.StatusOK {
-			errs <- fmt.Errorf("tasks/resubscribe: status %d", resp.StatusCode)
-			return
-		}
-		scanner := bufio.NewScanner(resp.Body)
-		for scanner.Scan() {
-			line := scanner.Text()
-			if !strings.HasPrefix(line, "data:") {
-				continue
-			}
-			payload := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
-			if payload == "" {
-				continue
-			}
-			var out struct {
-				Result Task      `json:"result"`
-				Error  *rpcError `json:"error"`
-			}
-			if err := json.Unmarshal([]byte(payload), &out); err != nil {
-				errs <- err
-				return
-			}
-			if out.Error != nil {
-				errs <- fmt.Errorf("a2a tasks/resubscribe: %s (%d)", out.Error.Message, out.Error.Code)
-				return
-			}
-			select {
-			case <-ctx.Done():
-				errs <- ctx.Err()
-				return
-			case tasks <- out.Result:
-			}
-			if terminal(out.Result.Status.State) {
-				return
-			}
-		}
-		if err := scanner.Err(); err != nil {
-			errs <- err
-		}
-	}()
-	return tasks, errs
-}
-
 // SetPushNotificationConfig asks the remote agent to POST updates for taskID to cfg.URL.
 func (c *Client) SetPushNotificationConfig(ctx context.Context, taskID string, cfg PushNotificationConfig) error {
 	_, err := c.call(ctx, "tasks/pushNotificationConfig/set", pushConfigParams{
@@ -266,7 +193,7 @@ func (c *Client) call(ctx context.Context, method string, params any) (json.RawM

 func terminal(state string) bool {
 	switch state {
-	case "completed", "failed", "canceled", "rejected", "input-required":
+	case "completed", "failed", "canceled", "rejected":
 		return true
 	}
 	return false
@@ -3,10 +3,8 @@ package a2a
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"net/http"
 	"net/http/httptest"
-	"strings"
 	"testing"
 	"time"
 )
@@ -112,57 +110,3 @@ func TestClientContinuesTaskAndConfiguresPush(t *testing.T) {
 		t.Fatal("timed out waiting for push update")
 	}
 }
-
-func TestClientResubscribeStreamsRetainedAndLiveTask(t *testing.T) {
-	d := newDispatcher()
-	initial := &Task{ID: "task-1", ContextID: "ctx-1", Kind: "task", Status: TaskStatus{State: stateWorking, Timestamp: time.Now().UTC().Format(time.RFC3339)}}
-	d.store(initial)
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		d.serve(w, r, func(context.Context, string) (string, error) { return "", nil })
-	}))
-	defer ts.Close()
-
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancel()
-	tasks, errs := NewClient(ts.URL).Resubscribe(ctx, initial.ID)
-
-	first := <-tasks
-	if first.ID != initial.ID || first.Status.State != stateWorking {
-		t.Fatalf("first resubscribe task = %+v, want retained working task", first)
-	}
-	final := &Task{ID: initial.ID, ContextID: initial.ContextID, Kind: "task", Status: TaskStatus{State: stateCompleted, Timestamp: time.Now().UTC().Format(time.RFC3339)}, Artifacts: []Artifact{textArtifact("done")}}
-	d.store(final)
-	second := <-tasks
-	if second.ID != final.ID || second.Status.State != stateCompleted || textOf(second.Artifacts[0].Parts) != "done" {
-		t.Fatalf("second resubscribe task = %+v, want live completed task", second)
-	}
-	if _, ok := <-tasks; ok {
-		t.Fatal("resubscribe task channel stayed open after terminal update")
-	}
-	select {
-	case err := <-errs:
-		if err != nil {
-			t.Fatalf("resubscribe error = %v", err)
-		}
-	default:
-	}
-}
-
-func TestClientSendMessageReturnsInputRequiredTask(t *testing.T) {
-	card := Card("solo", "http://localhost:4000", "", []string{"task"})
-	h := NewAgentHandler(card, func(context.Context, string) (string, error) {
-		return "", errors.New("input-required: provide approval code")
-	})
-	ts := httptest.NewServer(h)
-	defer ts.Close()
-
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancel()
-	task, err := NewClient(ts.URL).SendMessage(ctx, Message{Parts: []Part{{Kind: "text", Text: "approve?"}}})
-	if err != nil {
-		t.Fatalf("SendMessage: %v", err)
-	}
-	if task.Status.State != stateInputRequired || !strings.Contains(textOf(task.Artifacts[0].Parts), "provide approval code") {
-		t.Fatalf("task = %+v, want input-required handoff", task)
-	}
-}
@@ -29,18 +29,6 @@ consistent across providers.
 The companion `TestAgentProviderConformanceFakeError` keeps provider error
 propagation covered locally without relying on external credentials.

-## Local no-secret conformance
-
-Use `make provider-conformance-mock` to run the same provider conformance harness
-through the deterministic mock provider. That target requires no API keys and is
-what `make harness` delegates to after the 0→1 and 0→hero scenarios, so every PR
-continues to exercise the provider-facing agent/tool contract without spending
-live model credits.
-
-Use `make provider-conformance` when you want the live-provider sweep: providers
-without keys are skipped, and configured providers must satisfy the same harness
-contract.
-
 ## Scheduled CI

 The daily/manual `Harness (E2E)` workflow runs the same matrix with
@@ -10,26 +10,6 @@ and can stop or revert anything at any time.
 > **services → agents → workflows**. Judge each change against it — work that
 > doesn't move toward that lifecycle isn't an improvement, however clean.

-## The pipeline (planner → generator → evaluator)
-
-The development process is an operational instance of the long-running-agent
-harness pattern ([Anthropic on harness design](https://www.anthropic.com/engineering/harness-design-long-running-apps)) —
-a planner, a generator, and a *separate* evaluator — distributed across GitHub
-Actions instead of subagents. Each role is a workflow:
-
-| Role | Workflow (action name) | What it does |
-|------|------------------------|--------------|
-| **Planner** | `loop-architect.yml` — *Loop: Architect (Planner)* | Tracks live state, prioritizes the roadmap + an internal scan, and maintains the ranked queue in [`PRIORITIES.md`](PRIORITIES.md). Decides *what*. |
-| **Generator** | `loop-builder.yml` — *Loop: Builder (Generator)* | Builds the top open queue item as a single-concern PR (via Codex) and self-merges on green CI. Does the work. |
-| **Evaluator** | `harness.yml` — *Harness (E2E)*, plus the CI gate (`tests.yaml`, `lint.yaml`) | Grades every change: the mock harness + unit/lint on each push/PR, and real-model conformance hourly. A *separate* grader — never the generator judging itself. |
-| **Evaluator → feedback** | `loop-triage.yml` — *Loop: Triage (Evaluator feedback)* | On harness failure, root-causes, dedupes, and files scoped fix issues back into the planner's queue. The hill-climbing feedback path. |
-| **Coherence** | `loop-devrel.yml` — *Loop: DevRel* | Keeps README/website/docs/blog aligned with the North Star. |
-| **Release** | `loop-release.yml` — *Loop: Release (daily patch)* | Cuts a daily patch tag when master has new commits, so the *installable* framework tracks the loop's improvements (triggers `release.yml`/goreleaser). Minor/major bumps stay with the human. |
-
-Generation is separated from evaluation on purpose: an agent grading its own work
-reliably over-rates it, so **CI and the harness — not the builder — are the gate**.
-The human sets direction and owns the calls that need taste (see Guardrails).
-
 ## Autonomy

 Full autonomy, **no approval gates**. Each increment: Claude Code picks the work,
@@ -92,7 +72,7 @@ Grounded in real signal, never speculative rewrites. Each cycle draws from:
  tracking issue for each increment and dispatches Codex there. It needs a
  `CODEX_TRIGGER_TOKEN` repo secret from a user account Codex responds to;
  without that secret the workflow deliberately no-ops to avoid ignored bot
-  comments. See `.github/workflows/loop-builder.yml` and the mechanics
+  comments. See `.github/workflows/continuous-improvement.yml` and the mechanics
  below.

 ## How the durable loop works (mechanics)
@@ -147,13 +127,13 @@ The hourly loop ships increments; two periodic passes keep the *whole* heading i
 the right direction. Both use the same mechanism (fresh issue → `@codex` →
 output) but produce direction and coherence, not just code.

- **DevRel — daily** (`.github/workflows/loop-devrel.yml`). Audits the public
+- **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 — continuous (hourly)** (`.github/workflows/loop-architect.yml`).
+- **Architect — continuous (hourly)** (`.github/workflows/architecture-review.yml`).
  The *founder lens*, running alongside the builders. Each run it **tracks live
  state** (what just merged, what's in flight), **prioritizes the roadmap**
  (`ROADMAP.md`, Now → Next → Later) against an internal scan (lifecycle gaps, API
@@ -174,20 +154,6 @@ roadmap-driven by default, not a fresh guess every hour. Cadence is tunable in e
 workflow's `cron`; the human can reorder `PRIORITIES.md` or its issues at any time
 to redirect. Codex is serial, so these passes queue behind any in-flight increment.

-## Failure triage (the feedback loop)
-
-The loop also closes on its own failures. `.github/workflows/loop-triage.yml`
-fires when the live provider-conformance harness finishes with `conclusion:
-failure` (scheduled/manual runs only), and dispatches Codex to **triage** the
-failing run: read the logs, root-cause each distinct failure, **dedupe** against
-open issues (comment "recurred" rather than filing a duplicate), and file a scoped
-`codex`/`enhancement` issue for each genuine, self-contained defect — which the
-increment loop then builds and the next harness run verifies. Transient flakes
-(live-model latency, provider outages) are ignored; anything needing a breaking or
-architectural change is escalated as `needs-human` instead of auto-built. This is
-the hill-climbing layer: CI/harness failures become fixes with no human in the
-middle, short of a decision that's genuinely the human's.
-
 ## Stop / redirect

 - In-session: `CronDelete <id>` (or end the session).
@@ -21,16 +21,7 @@ changes, architectural rewrites. Those go to the human.

 ## Work queue (ranked)

-1. **Write a “Your First Agent” walkthrough that takes a developer from services to an agent end to end** ([#3561](https://github.com/micro/go-micro/issues/3561)) — the current adoption gap is the on-ramp, not another internal primitive. This should be the highest-value Now/DX task: a walkable, CI-verifiable first-agent path that proves “building an agent is as easy as building a service” and gives new users an immediate win.
-2. **Lead install docs with `@latest` now that the phantom-module retraction is published** ([#3565](https://github.com/micro/go-micro/issues/3565)) — install friction blocks every later experience. Make the first command current, boring, and consistent across README/website/docs so revived usage does not stall before scaffold/run.
-3. **Surface runnable examples from getting-started and the guides** ([#3562](https://github.com/micro/go-micro/issues/3562)) — the blog canon now has a concrete support-agent story, but developers need obvious links from docs into runnable code. Tie examples to the 0→1 and 0→hero paths so “read → run → modify one thing” is discoverable.
-4. **Reorder the guides nav to lead with doing before concepts** ([#3563](https://github.com/micro/go-micro/issues/3563)) — the framework is deep, but the first impression should be action: quickstart, first agent, examples, debugging, then architecture. This is small, CI-checkable wayfinding work with outsized adoption value.
-5. **Add a “Debugging your agent” guide focused on the dev workflow** ([#3564](https://github.com/micro/go-micro/issues/3564)) — the inner loop is scaffold → run → chat → inspect → deploy. Document how to see tool calls, run history, provider failures, guardrail refusals, and flow handoffs before adding more depth that users cannot diagnose.
-6. **Prevent duplicate tool side effects in the plan/delegate harness** ([#3559](https://github.com/micro/go-micro/issues/3559)) — correctness still matters where it protects real user trust. Plan/delegate is central to the services → agents lifecycle, and duplicate side effects undermine the “agent as dependable service” story.
-7. **Expose `fallback_echo` during A2A streaming fallback conformance** ([#3560](https://github.com/micro/go-micro/issues/3560)) — keep interop conformance trustworthy without letting it dominate the adoption queue. This is scoped, testable, and protects the A2A promise developers see in the README and site.
-8. **Propagate agent run cancellation and deadlines through model and tool calls** ([#3544](https://github.com/micro/go-micro/issues/3544)) — after the on-ramp items, the highest-value remaining Now-phase resilience gap is predictable failure semantics across agent runs, model calls, tool calls, plan/delegate, and flow handoffs. Tool retries and live-provider deadline tuning are in place; the lifecycle still needs cancellation/deadline propagation so work fails safely instead of becoming opaque loops.
-9. **Emit OpenTelemetry spans for agent run timelines** ([#3525](https://github.com/micro/go-micro/issues/3525)) — recent work made runs inspectable, correlated trace metadata through scheduled dispatch, verified restart resume, added opt-in tool retries, hardened provider conformance, and fixed provider-emitted text tool calls. The next Next-phase step is to turn that RunInfo foundation into standard OTel spans for agent runs, model calls, tool calls, checkpoint/resume, cancellation/deadlines, and failures.
-10. **Add an AP2 mandate layer over A2A and x402** ([#3552](https://github.com/micro/go-micro/issues/3552)) — this is a forward interop investment, not a Now-phase blocker: Go Micro already has A2A agents and x402 paid tools, so a small signed-mandate foundation can keep agent payments aligned with the open-protocol story without pulling the queue away from adoption, resilience, or observability. Keep it additive and opt-in while the AP2/FIDO work settles.
+1. **Make long agent runs resumable from checkpoints** ([#3449](https://github.com/micro/go-micro/issues/3449)) — the flow grader loop shipped in #3443 and the run-trace analyzer shipped in #3447, closing the previous top queue item (#3439). With flow durability and optimization now proving the workflow side, the highest-value remaining lifecycle seam is agent-run durability: long agent loops should persist enough progress to resume without replaying completed tool side effects. This aligns the services → agents → workflows runtime by giving agents the same operable recovery posture that flows already have, while staying scoped to a non-breaking, CI-verifiable checkpoint/resume contract.

 _Seeded by Claude Code from the roadmap + open issues; thereafter maintained by the
 architecture-review pass._
@@ -24,7 +24,6 @@ import (
 	"go-micro.dev/v6/agent"
 	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/gateway/a2a"
-	"go-micro.dev/v6/internal/harness/harnessutil"
 	"go-micro.dev/v6/registry"
 	"go-micro.dev/v6/store"
 )
@@ -96,7 +95,7 @@ func main() {
 	reg := registry.NewMemoryRegistry()
 	st := store.NewMemoryStore()
 	var sawTool, sawRunInfo bool
-	agentOpts := []agent.Option{
+	ag := agent.New(
 		agent.Name("a2a-fallback"),
 		agent.Provider(*provider),
 		agent.APIKey(apiKey),
@@ -104,7 +103,7 @@ func main() {
 		agent.WithRegistry(reg),
 		agent.WithStore(st),
 		agent.WithMemory(agent.NewInMemory(8)),
-		agent.ModelCallTimeout(45 * time.Second),
+		agent.ModelCallTimeout(45*time.Second),
 		agent.WithTool("fallback_echo", "Echo the A2A fallback marker.", map[string]any{
 			"value": map[string]any{"type": "string", "description": "value to echo"},
 		}, func(ctx context.Context, input map[string]any) (string, error) {
@@ -119,9 +118,7 @@ func main() {
 			}
 			return `{"marker":"a2a-fallback-ok"}`, nil
 		}),
-	}
-	agentOpts = append(agentOpts, harnessutil.AgentOptions(*provider)...)
-	ag := agent.New(agentOpts...)
+	)

 	card := a2a.Card("a2a-fallback", "http://example.invalid/a2a-fallback", "", nil)
 	handler := a2a.NewAgentStreamHandler(card, func(ctx context.Context, text string) (string, error) {
@@ -25,9 +25,10 @@ import (
 	"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/internal/harness/harnessutil"
 	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/selector"
 	"go-micro.dev/v6/service"
 	"go-micro.dev/v6/store"
 )
@@ -202,9 +203,8 @@ func main() {
 		fmt.Println("broker connect:", err)
 		os.Exit(1)
 	}
-	cl := harnessutil.Client(*provider, reg)
+	cl := client.NewClient(client.Registry(reg), client.Selector(selector.NewSelector(selector.Registry(reg))))
 	mem := store.NewMemoryStore()
-	liveAgentOpts := harnessutil.AgentOptions(*provider)

 	wsSvc := new(WorkspaceService)
 	ws := service.New(service.Name("workspace"), service.Address("127.0.0.1:0"), service.Registry(reg), service.Client(cl))
@@ -217,7 +217,7 @@ func main() {
 	go nt.Run()

 	// The onboarder agent, registered so the flow can reach it over RPC.
-	onboarderOpts := []agent.Option{
+	onboarder := agent.New(
 		agent.Name("onboarder"),
 		agent.Address("127.0.0.1:0"),
 		agent.Services("workspace", "notify"),
@@ -225,9 +225,7 @@ func main() {
 		agent.Provider(*provider),
 		agent.APIKey(apiKey),
 		agent.WithRegistry(reg), agent.WithClient(cl), agent.WithStore(mem),
-	}
-	onboarderOpts = append(onboarderOpts, liveAgentOpts...)
-	onboarder := agent.New(onboarderOpts...)
+	)
 	go onboarder.Run()
 	defer onboarder.Stop()

@@ -240,7 +238,6 @@ func main() {
 		flow.Trigger("events.user.created"),
 		flow.Agent("onboarder"),
 		flow.Prompt("A new user signed up: {{.Data}}. Get them set up."),
-		flow.Timeout(harnessutil.LiveTimeout(*provider)),
 	)
 	if err := f.Register(reg, br, cl); err != nil {
 		fmt.Println("flow register:", err)
@@ -1,61 +0,0 @@
-package harnessutil
-
-import (
-	"fmt"
-	"os"
-	"time"
-
-	"go-micro.dev/v6/agent"
-	"go-micro.dev/v6/client"
-	"go-micro.dev/v6/registry"
-	"go-micro.dev/v6/selector"
-)
-
-const (
-	// LiveTimeoutEnv overrides the per-call deadline used by live-provider
-	// harness runs. It intentionally does not affect deterministic mock runs.
-	LiveTimeoutEnv = "GO_MICRO_HARNESS_LIVE_TIMEOUT"
-	// DefaultLiveTimeout is generous enough for slow but correct hosted models
-	// while still bounding genuinely stuck live conformance runs.
-	DefaultLiveTimeout = 5 * time.Minute
-)
-
-// LiveTimeout returns the harness per-call timeout for live providers. Mock runs
-// keep their historical fast defaults by returning zero.
-func LiveTimeout(provider string) time.Duration {
-	if provider == "mock" {
-		return 0
-	}
-	if raw := os.Getenv(LiveTimeoutEnv); raw != "" {
-		d, err := time.ParseDuration(raw)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "invalid %s=%q; using %s\n", LiveTimeoutEnv, raw, DefaultLiveTimeout)
-			return DefaultLiveTimeout
-		}
-		return d
-	}
-	return DefaultLiveTimeout
-}
-
-// Client returns an in-memory-registry client. Live provider harnesses get a
-// larger request timeout so an otherwise correct agent run is not cut off by the
-// default 30-second RPC deadline; mock runs are unchanged.
-func Client(provider string, reg registry.Registry) client.Client {
-	opts := []client.Option{
-		client.Registry(reg),
-		client.Selector(selector.NewSelector(selector.Registry(reg))),
-	}
-	if d := LiveTimeout(provider); d > 0 {
-		opts = append(opts, client.RequestTimeout(d))
-	}
-	return client.NewClient(opts...)
-}
-
-// AgentOptions applies the same live-provider timeout to model and tool calls.
-// The empty result for mock runs preserves their deterministic timing.
-func AgentOptions(provider string) []agent.Option {
-	if d := LiveTimeout(provider); d > 0 {
-		return []agent.Option{agent.ModelCallTimeout(d), agent.ToolCallTimeout(d)}
-	}
-	return nil
-}
@@ -1,33 +0,0 @@
-package harnessutil
-
-import (
-	"testing"
-	"time"
-)
-
-func TestLiveTimeoutLeavesMockUnchanged(t *testing.T) {
-	t.Setenv(LiveTimeoutEnv, "2m")
-	if got := LiveTimeout("mock"); got != 0 {
-		t.Fatalf("LiveTimeout(mock) = %s, want 0", got)
-	}
-	if opts := AgentOptions("mock"); len(opts) != 0 {
-		t.Fatalf("AgentOptions(mock) length = %d, want 0", len(opts))
-	}
-}
-
-func TestLiveTimeoutUsesDefaultForLiveProviders(t *testing.T) {
-	t.Setenv(LiveTimeoutEnv, "")
-	if got := LiveTimeout("atlascloud"); got != DefaultLiveTimeout {
-		t.Fatalf("LiveTimeout(live) = %s, want %s", got, DefaultLiveTimeout)
-	}
-	if opts := AgentOptions("atlascloud"); len(opts) != 2 {
-		t.Fatalf("AgentOptions(live) length = %d, want 2", len(opts))
-	}
-}
-
-func TestLiveTimeoutCanBeOverridden(t *testing.T) {
-	t.Setenv(LiveTimeoutEnv, "90s")
-	if got := LiveTimeout("anthropic"); got != 90*time.Second {
-		t.Fatalf("LiveTimeout override = %s, want 90s", got)
-	}
-}
@@ -26,9 +26,10 @@ import (
 	"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/internal/harness/harnessutil"
 	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/selector"
 	"go-micro.dev/v6/service"
 	"go-micro.dev/v6/store"
 )
@@ -240,9 +241,8 @@ func runPlanDelegate(provider string) error {
 	fmt.Print("Real services, registry, RPC, agent loop, store, delegation.\n\n")

 	reg := registry.NewMemoryRegistry()
-	cl := harnessutil.Client(provider, reg)
+	cl := client.NewClient(client.Registry(reg), client.Selector(selector.NewSelector(selector.Registry(reg))))
 	mem := store.NewMemoryStore()
-	liveAgentOpts := harnessutil.AgentOptions(provider)

 	// Real services.
 	taskSvc := new(TaskService)
@@ -260,30 +260,26 @@ func runPlanDelegate(provider string) error {
 	go notify.Run()

 	// Real comms agent (owns notify), registered so delegate reaches it over RPC.
-	commsOpts := []agent.Option{
+	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),
-	}
-	commsOpts = append(commsOpts, liveAgentOpts...)
-	comms := agent.New(commsOpts...)
+	)
 	go comms.Run()
 	defer comms.Stop()

 	// Real conductor agent (owns task), registered so the flow can reach it over RPC.
-	conductorOpts := []agent.Option{
+	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),
-	}
-	conductorOpts = append(conductorOpts, liveAgentOpts...)
-	conductor := agent.New(conductorOpts...)
+	)
 	go conductor.Run()
 	defer conductor.Stop()

@@ -307,7 +303,6 @@ func runPlanDelegate(provider string) error {
 	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}}"),
-		flow.Timeout(harnessutil.LiveTimeout(provider)),
 	)
 	if err := f.Register(reg, broker.DefaultBroker, cl); err != nil {
 		return fmt.Errorf("flow register: %w", err)
@@ -20,11 +20,7 @@ agent test and the harnesses in `internal/harness`:
  preserving run metadata.

 The command also emits the registered provider capability matrix so the run shows
-which providers advertise model, image, video, and streaming support. Console output
-and summary artifacts label each harness with the phase it is proving (for example,
-model call + tool call, workflow event + tool call, or streaming fallback + tool
-call), so provider failures identify the failed lifecycle phase instead of only the
-provider name.
+which providers advertise model, image, video, and streaming support.

 ## Local usage

@@ -56,8 +52,7 @@ Provider keys are read from `MICRO_AI_API_KEY` or the provider-specific variable
 | AtlasCloud | `ATLASCLOUD_API_KEY` |

 Use `-require-configured` when you want a selected provider without a key to fail
-instead of skip. This is useful for manually checking that a required provider
-secret is actually wired into CI before relying on that provider as covered:
+instead of skip:

 ```sh
 go run ./internal/harness/provider-conformance \
@@ -68,12 +63,8 @@ go run ./internal/harness/provider-conformance \
 ## Scheduled CI behavior

 The `Harness (E2E)` workflow runs on pushes and pull requests with deterministic
-mock LLMs, including `provider-conformance -providers mock`. On the daily
-schedule and manual dispatch it also runs the live provider conformance job. A
-manual dispatch can narrow `providers` or `harnesses`, and can set
-`require_configured=true` to fail fast when an expected repository secret is
-missing; scheduled runs keep the safe default and report missing keys as skips.
-That job:
+mock LLMs, including `provider-conformance -providers mock`. On the daily schedule and manual dispatch it also runs the live
+provider conformance job. That job:

 1. runs the same `agent`, `universe`, `agent-flow`, `plan-delegate`, and `a2a-stream-fallback` harness list,
 2. reads the provider keys from repository secrets,
@@ -34,16 +34,6 @@ import (
 	_ "go-micro.dev/v6/ai/together"
 )

-const defaultHarnesses = "agent,universe,agent-flow,plan-delegate,a2a-stream-fallback"
-
-var harnessPhases = map[string]string{
-	"agent":               "model call + tool call",
-	"universe":            "service discovery + tool call",
-	"agent-flow":          "workflow event + tool call",
-	"plan-delegate":       "plan persistence + delegation + tool call",
-	"a2a-stream-fallback": "streaming fallback + tool call",
-}
-
 var providerEnv = map[string]string{
 	"anthropic":  "ANTHROPIC_API_KEY",
 	"openai":     "OPENAI_API_KEY",
@@ -55,8 +45,8 @@ var providerEnv = map[string]string{
 }

 func main() {
-	providersFlag := flag.String("providers", defaultProviders(), "comma-separated providers to check; use mock for deterministic local checks")
-	harnessesFlag := flag.String("harnesses", defaultHarnesses, "comma-separated harness names under internal/harness; agent runs the provider tool-call conformance test")
+	providersFlag := flag.String("providers", "anthropic,openai,gemini,groq,mistral,together,atlascloud", "comma-separated providers to check; use mock for deterministic local checks")
+	harnessesFlag := flag.String("harnesses", "agent,universe,agent-flow,plan-delegate,a2a-stream-fallback", "comma-separated harness names under internal/harness; agent runs the provider tool-call conformance test")
 	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")
@@ -100,16 +90,15 @@ func main() {
 		}

 		for _, harness := range harnesses {
-			phase := harnessPhase(harness)
-			fmt.Printf("\n==> %s / %s (%s)\n", provider, harness, phase)
+			fmt.Printf("\n==> %s / %s\n", provider, harness)
 			if err := runHarness(provider, harness, *timeoutFlag); err != nil {
-				fmt.Printf("FAIL %s / %s (%s): %v\n", provider, harness, phase, err)
+				fmt.Printf("FAIL %s / %s: %v\n", provider, harness, err)
 				failed++
-				results = append(results, conformanceResult{Provider: provider, Harness: harness, Phase: phase, Status: statusFailed, Error: err.Error()})
+				results = append(results, conformanceResult{Provider: provider, Harness: harness, Status: statusFailed, Error: err.Error()})
 				continue
 			}
 			ran++
-			results = append(results, conformanceResult{Provider: provider, Harness: harness, Phase: phase, Status: statusPassed})
+			results = append(results, conformanceResult{Provider: provider, Harness: harness, Status: statusPassed})
 		}
 	}

@@ -149,7 +138,6 @@ const (
 type conformanceResult struct {
 	Provider string `json:"provider"`
 	Harness  string `json:"harness,omitempty"`
-	Phase    string `json:"phase,omitempty"`
 	Status   string `json:"status"`
 	Error    string `json:"error,omitempty"`
 }
@@ -181,23 +169,17 @@ 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)
-	fmt.Fprintf(&b, "Providers: %s.\n\n", markdownList(summary.Providers))
-	fmt.Fprintf(&b, "Harnesses: %s.\n\n", markdownList(summary.Harnesses))
 	b.WriteString("## Capability matrix\n\n")
 	b.WriteString(capabilityMarkdown(summary.Capabilities))
 	b.WriteString("\n## Harness results\n\n")
-	b.WriteString("| Provider | Harness | Phase | Status | Detail |\n")
-	b.WriteString("| --- | --- | --- | --- | --- |\n")
+	b.WriteString("| Provider | Harness | Status | Detail |\n")
+	b.WriteString("| --- | --- | --- | --- |\n")
 	for _, result := range summary.Results {
 		harness := result.Harness
 		if harness == "" {
 			harness = "—"
 		}
-		phase := result.Phase
-		if phase == "" {
-			phase = "—"
-		}
-		fmt.Fprintf(&b, "| %s | %s | %s | %s | %s |\n", result.Provider, harness, markdownCell(phase), result.Status, markdownCell(result.Error))
+		fmt.Fprintf(&b, "| %s | %s | %s | %s |\n", result.Provider, harness, result.Status, markdownCell(result.Error))
 	}
 	return os.WriteFile(path, []byte(b.String()), 0o644)
 }
@@ -212,24 +194,6 @@ func capabilityMarkdown(rows []ai.CapabilityRow) string {
 	return b.String()
 }

-func markdownList(values []string) string {
-	if len(values) == 0 {
-		return "—"
-	}
-	escaped := make([]string, 0, len(values))
-	for _, value := range values {
-		escaped = append(escaped, "`"+strings.ReplaceAll(value, "`", "\\`")+"`")
-	}
-	return strings.Join(escaped, ", ")
-}
-
-func harnessPhase(harness string) string {
-	if phase, ok := harnessPhases[harness]; ok {
-		return phase
-	}
-	return "harness"
-}
-
 func markdownCell(s string) string {
 	if s == "" {
 		return "—"
@@ -315,15 +279,6 @@ func repoRoot() string {
 	}
 }

-func defaultProviders() string {
-	providers := make([]string, 0, len(providerEnv))
-	for provider := range providerEnv {
-		providers = append(providers, provider)
-	}
-	slices.Sort(providers)
-	return strings.Join(providers, ",")
-}
-
 func knownProviders() string {
 	providers := make([]string, 0, len(providerEnv)+1)
 	providers = append(providers, "mock")
@@ -36,18 +36,6 @@ func TestValidateSelectionRejectsUnsafeHarnessName(t *testing.T) {
 	}
 }

-func TestDefaultProvidersTracksLiveProviderSet(t *testing.T) {
-	got := defaultProviders()
-	for _, want := range []string{"anthropic", "openai", "gemini", "groq", "mistral", "together", "atlascloud"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("defaultProviders() = %q, want %q", got, want)
-		}
-	}
-	if strings.Contains(got, "mock") {
-		t.Fatalf("defaultProviders() = %q, should not include mock in live scheduled defaults", got)
-	}
-}
-
 func TestCapabilityMatrixHasRegisteredProviders(t *testing.T) {
 	rows := ai.CapabilityRows()
 	if len(rows) == 0 {
@@ -99,7 +87,7 @@ func TestWriteSummaryMarkdown(t *testing.T) {
 	summary := conformanceSummary{
 		Capabilities: []ai.CapabilityRow{{Provider: "mock", Capabilities: ai.Capabilities{Model: true}}},
 		Results: []conformanceResult{
-			{Provider: "mock", Harness: "agent-flow", Phase: harnessPhase("agent-flow"), Status: statusPassed},
+			{Provider: "mock", Harness: "agent-flow", Status: statusPassed},
 			{Provider: "live", Status: statusSkipped, Error: "missing | key"},
 		},
 		Passed:  1,
@@ -117,11 +105,9 @@ func TestWriteSummaryMarkdown(t *testing.T) {
 	for _, want := range []string{
 		"# Provider conformance summary",
 		"Passed: 1. Skipped providers: 1. Failed: 0.",
-		"Providers: —.",
-		"Harnesses: —.",
 		"| mock | ✅ | — | — | — |",
-		"| mock | agent-flow | workflow event + tool call | passed | — |",
-		"| live | — | — | skipped | missing \\| key |",
+		"| mock | agent-flow | passed | — |",
+		"| live | — | skipped | missing \\| key |",
 	} {
 		if !strings.Contains(got, want) {
 			t.Fatalf("summary markdown = %q, want %q", got, want)
@@ -129,23 +115,6 @@ func TestWriteSummaryMarkdown(t *testing.T) {
 	}
 }

-func TestHarnessPhaseLabelsKnownHarnesses(t *testing.T) {
-	if got := harnessPhase("a2a-stream-fallback"); got != "streaming fallback + tool call" {
-		t.Fatalf("harnessPhase() = %q, want streaming fallback phase", got)
-	}
-	if got := harnessPhase("custom"); got != "harness" {
-		t.Fatalf("harnessPhase(custom) = %q, want fallback phase", got)
-	}
-}
-
-func TestMarkdownListEscapesBackticks(t *testing.T) {
-	got := markdownList([]string{"agent", "bad`name"})
-	want := "`agent`, `bad\\`name`"
-	if got != want {
-		t.Fatalf("markdownList() = %q, want %q", got, want)
-	}
-}
-
 func TestWriteSummaryJSON(t *testing.T) {
 	path := filepath.Join(t.TempDir(), "summary.json")
 	summary := conformanceSummary{
@@ -38,10 +38,11 @@ import (
 	"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/gateway/a2a"
-	"go-micro.dev/v6/internal/harness/harnessutil"
 	"go-micro.dev/v6/registry"
+	"go-micro.dev/v6/selector"
 	"go-micro.dev/v6/service"
 	"go-micro.dev/v6/store"
 )
@@ -228,9 +229,8 @@ func runUniverse(provider string) int {
 		fmt.Println("broker connect:", err)
 		return 2
 	}
-	cl := harnessutil.Client(provider, reg)
+	cl := client.NewClient(client.Registry(reg), client.Selector(selector.NewSelector(selector.Registry(reg))))
 	st := store.NewMemoryStore()
-	liveAgentOpts := harnessutil.AgentOptions(provider)

 	// Services.
 	inv, pay, ord, ntf := new(Inventory), new(Payment), new(Orders), new(Notify)
@@ -243,7 +243,7 @@ func runUniverse(provider string) int {
 	// The concierge agent: guardrails on, plus a tool-execution wrapper
 	// that counts calls — to prove the wrapper seam runs end-to-end.
 	var wrapped int64
-	conciergeOpts := []agent.Option{
+	concierge := agent.New(
 		agent.Name("concierge"),
 		agent.Services("notify"),
 		agent.Prompt("You notify buyers when their order is confirmed."),
@@ -257,9 +257,7 @@ func runUniverse(provider string) int {
 			}
 		}),
 		agent.WithRegistry(reg), agent.WithClient(cl), agent.WithStore(st),
-	}
-	conciergeOpts = append(conciergeOpts, liveAgentOpts...)
-	concierge := agent.New(conciergeOpts...)
+	)
 	go concierge.Run()
 	defer concierge.Stop()

@@ -270,7 +268,6 @@ func runUniverse(provider string) int {
 	checkout := flow.New("checkout",
 		flow.Trigger("events.order.placed"),
 		flow.WithCheckpoint(flow.StoreCheckpoint(st, "checkout")),
-		flow.Timeout(harnessutil.LiveTimeout(provider)),
 		flow.Steps(
 			flow.Step{Name: "reserve", Run: flow.Call("inventory", "Inventory.Reserve")},
 			flow.Step{Name: "charge", Run: flow.Call("payment", "Payment.Charge")},
@@ -1,48 +0,0 @@
-package zerotoheroci
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestZeroToHeroReferenceDocs(t *testing.T) {
-	root := filepath.Clean(filepath.Join("..", "..", ".."))
-
-	guide := readFile(t, filepath.Join(root, "internal", "website", "docs", "guides", "zero-to-hero.md"))
-	for _, want := range []string{
-		"make harness",
-		"go test ./cmd/micro/cli/new -run TestZeroToOne -count=1",
-		"go test ./cmd/micro -run TestZeroToHeroCLIBoundaries -count=1",
-		"go test ./cmd/micro/cli/deploy -run TestDeployDryRun -count=1",
-		"./internal/harness/zero-to-hero-ci/run.sh",
-		"go run ./internal/harness/agent-flow",
-		"make provider-conformance-mock",
-		"internal/harness/plan-delegate",
-		"internal/harness/universe",
-	} {
-		if !strings.Contains(guide, want) {
-			t.Fatalf("0→hero guide missing %q", want)
-		}
-	}
-
-	readme := readFile(t, filepath.Join(root, "README.md"))
-	if !strings.Contains(readme, "internal/website/docs/guides/zero-to-hero.md") {
-		t.Fatal("README does not point to the canonical 0→hero guide")
-	}
-
-	nav := readFile(t, filepath.Join(root, "internal", "website", "_data", "navigation.yml"))
-	if !strings.Contains(nav, "0→hero Reference") || !strings.Contains(nav, "/docs/guides/zero-to-hero.html") {
-		t.Fatal("website navigation does not expose the canonical 0→hero guide")
-	}
-}
-
-func readFile(t *testing.T, name string) string {
-	t.Helper()
-	data, err := os.ReadFile(name)
-	if err != nil {
-		t.Fatalf("read %s: %v", name, err)
-	}
-	return string(data)
-}
@@ -32,8 +32,6 @@ examples:
  - title: Real-World Examples
    url: /docs/examples/realworld/
 guides:
-  - title: 0→hero Reference
-    url: /docs/guides/zero-to-hero.html
  - title: The Agent Harness
    url: /docs/guides/agent-harness.html
  - title: Agents and Workflows
@@ -72,7 +70,6 @@ project:
  - title: Server (optional)
    url: /docs/server.html
 search_order:
-  - /docs/guides/zero-to-hero.html
  - /docs/getting-started.html
  - /docs/mcp.html
  - /docs/architecture.html
@@ -1,5 +1,4 @@
 <a href="/docs/">Docs</a> &middot;
 <a href="/blog/">Blog</a> &middot;
 <a href="https://github.com/micro/go-micro">GitHub</a> &middot;
-<a href="https://discord.gg/G8Gk5j3uXr">Discord</a> &middot;
 <a href="/support">Support</a>
@@ -1,5 +1,4 @@
 <a href="/docs/">Docs</a>
 <a href="/blog/">Blog</a>
 <a href="/support"{% if page.nav_active == 'support' %} class="active"{% endif %}>Support</a>
-<a href="https://discord.gg/G8Gk5j3uXr">Discord</a>
 <a href="https://github.com/micro/go-micro">GitHub</a>
@@ -177,4 +177,4 @@ The future of microservices isn't fewer services. It's making them so easy to cr

 ---

-*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/G8Gk5j3uXr), or read the [docs](https://go-micro.dev/docs).*
+*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/WeMU5AGxD), or read the [docs](https://go-micro.dev/docs).*
@@ -102,4 +102,4 @@ micro chat --provider anthropic

 ---

-*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/G8Gk5j3uXr), or read the [docs](https://go-micro.dev/docs).*
+*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/WeMU5AGxD), or read the [docs](https://go-micro.dev/docs).*
@@ -144,4 +144,4 @@ The agent for your services answers. Not because you wired it up. Because the sy

 ---

-*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/G8Gk5j3uXr), or read the [docs](https://go-micro.dev/docs).*
+*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/WeMU5AGxD), or read the [docs](https://go-micro.dev/docs).*
@@ -135,8 +135,8 @@ The store backend determines durability — file-backed by default, Postgres or
 | **What** | Capability | Intelligence | Event orchestration |
 | **Does** | Handles requests | Manages services | Reacts to events |
 | **Knows** | Its endpoints | Its services' endpoints | Its trigger topic |
-| **State** | Store | Store-backed memory | Checkpointed run history |
-| **Create** | `micro.NewService("name")` | `micro.NewAgent("name")` | `micro.NewFlow("name")` |
+| **State** | Store | Store (memory) | Stateless per event |
+| **Create** | `micro.NewService()` | `micro.NewAgent()` | `micro.NewFlow()` |
 | **Package** | `service/` | `agent/` | `flow/` |

 They compose:
@@ -164,7 +164,7 @@ Or build an agent in Go:
 ```go
 package main

-import "go-micro.dev/v6"
+import "go-micro.dev/v5"

 func main() {
    agent := micro.NewAgent("task-mgr",
@@ -176,8 +176,8 @@ func main() {
 }
 ```

-The agent implementation lives under `go-micro.dev/v6/agent`; most users create agents through the top-level `go-micro.dev/v6` API. The full interface design is documented in [AGENT_DESIGN.md](https://github.com/micro/go-micro/blob/master/internal/docs/AGENT_DESIGN.md).
+The agent package is at `go-micro.dev/v5/agent`. The full interface design is documented in [AGENT_DESIGN.md](https://github.com/micro/go-micro/blob/master/internal/docs/AGENT_DESIGN.md).

 ---

-*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/G8Gk5j3uXr), or read the [docs](https://go-micro.dev/docs).*
+*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/WeMU5AGxD), or read the [docs](https://go-micro.dev/docs).*
@@ -165,4 +165,4 @@ Read the [Plan & Delegate guide](/docs/guides/plan-delegate) for the full refere

 ---

-*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/G8Gk5j3uXr), or read the [docs](https://go-micro.dev/docs).*
+*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/WeMU5AGxD), or read the [docs](https://go-micro.dev/docs).*
@@ -90,4 +90,4 @@ curl -fsSL https://go-micro.dev/install.sh | sh

 ---

-*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/G8Gk5j3uXr), or read the [docs](https://go-micro.dev/docs).*
+*Go Micro is open source. Star us on [GitHub](https://github.com/micro/go-micro), join the [Discord](https://discord.gg/WeMU5AGxD), or read the [docs](https://go-micro.dev/docs).*
@@ -58,4 +58,4 @@ A small end-to-end harness now boots a real world (services, a durable flow that

 The upshot is that building an agent in Go Micro looks like building a service, because underneath it is one. The infrastructure for a system of agents is, for the most part, the infrastructure for a system of services, and that is the decade of work already in the framework. Services remain the foundation; agents are what we are building on top of them.

-Thanks to Anthropic for the sponsorship. Join us in a new [Discord](https://discord.gg/G8Gk5j3uXr) to discuss the future of the project. 
+Thanks to Anthropic for the sponsorship. Join us in a new [Discord](https://discord.gg/WeMU5AGxD) to discuss the future of the project. 
@@ -49,4 +49,4 @@ V6 is the beginning of something real. It's secure by default, leads with agents

 Projects dont come back from the dead like this. AI brought it back from the dead. Agents made services more relevant. And Claude Code made it possible for me to ship code again.

-Thanks to Anthropic for the grant and the sponsorship. Join me in the [Discord](https://discord.gg/G8Gk5j3uXr) to discuss further.
+Thanks to Anthropic for the grant and the sponsorship. Join me in the [Discord](https://discord.gg/WeMU5AGxD) to discuss further.
@@ -1,89 +0,0 @@
---
-layout: blog
-title: "An Agent Is a Service: Where Agent Frameworks Are Going"
-permalink: /blog/32
-description: "A field guide to the agent-framework landscape — from LangChain and the first wave, through the two layers of a harness and the rise of loop engineering, to where the frameworks diverge. And why Go Micro's answer is that an agent is a service."
---
-
-# An Agent Is a Service: Where Agent Frameworks Are Going
-
-*June 30, 2026 • By the Go Micro Team*
-
-There are now a lot of ways to build an agent. LangChain and LangGraph, LlamaIndex, CrewAI, Microsoft's AutoGen, Google's ADK, the model labs' own SDKs, and — most recently in our own backyard — [tRPC-Agent-Go](https://github.com/trpc-group/trpc-agent-go) from Tencent. They are not all solving the same problem, and the places they differ tell you a lot about where this is heading.
-
-This is a field guide to that landscape, and an honest account of where Go Micro sits in it.
-
-## The first wave: a model in a loop
-
-The first wave of agent frameworks solved one thing: get a model to call tools in a loop until a task is done. LangChain, more than any other project, defined that category in 2022 — chains, then agents, then graphs. LlamaIndex came at it from the data and retrieval side. CrewAI and AutoGen leaned into multi-agent orchestration — crews and conversations of role-played agents. The model labs shipped their own agent SDKs so you could stay close to the metal.
-
-That first problem — model, tools, a loop — is now largely commoditized. Every SDK does it, and they mostly do it well. Which means the interesting question has moved. It is no longer "how do I get a model to use a tool." It is everything that happens *around* the loop once the agent has to do real work: connect to real systems, hold state across restarts, recover from failure, be observed, be scheduled, and be reached by other agents. That is the part that decides whether an agent makes it out of a demo.
-
-LangChain itself is the clearest evidence. The framework was the distribution; the value moved to *operating* agents — which is why their commercial product is LangSmith (observability, evaluation, monitoring), not the framework. The lesson the pioneer taught is that the framework gets you to a running agent, and the hard, durable, valuable problems are in operating it.
-
-## "Agent = Model + Harness" — but a harness has two layers
-
-LangChain has a good framing for this: an agent is a model plus a *harness* — the runtime around the model that makes it useful. The framing is right. What is usually left implicit is that "harness" has two distinct layers, and almost all the frameworks live in the first one.
-
-**The intra-agent harness** is the runtime around a *single model*: the system prompt, the tool definitions, context management and compaction, the sandbox, self-verification, and the continuation loop that keeps the model going until it is done. LangChain and LangGraph, deepagents, Claude Code, and the model labs' SDKs are excellent at this. It is real, hard work, and it is most of what people mean when they say "agent framework."
-
-**The operational harness** is the distributed substrate an agent *operates inside*: services exposed as typed tools, discovery and RPC, durable and resumable runs, observability, scheduling, and the protocols agents use to reach each other. This is the layer where a single agent stops being a script and becomes part of a system — where many agents, many services, and many workflows have to compose without falling over.
-
-The first layer produces an agent. The second is where that agent has to live. Most frameworks build the first and leave the second to you — you bring your own services, your own discovery, your own durability, your own deployment. That is the gap that matters now, because the moment you have more than one agent or one service, the operational harness *is* the product.
-
-## The loop is the new frontier
-
-If the first wave was "a model in a loop," the direction now is what LangChain has started calling [loop engineering](https://www.langchain.com/blog/the-art-of-loop-engineering): stacking loops around the agent. It is a useful map. There is the **agent loop** (model calls tools until done), the **verification loop** (a grader checks the output against a rubric and sends failures back with feedback), the **event-driven loop** (the agent is triggered by webhooks, schedules, or messages instead of a human typing), and the **hill-climbing loop** (production traces feed back to improve the prompts, tools, and graders over time).
-
-Notice that only the first of those four is the intra-agent harness. The other three — verification, event-driven triggers, learning from traces — are the operational harness. The frontier is moving from "answer a prompt" to **scheduled, looping, work-performing agents**: agents that run on a cadence, do real work, check their own output, and get better. That is exactly the layer that is underbuilt, and it is the layer that decides whether agents are dependable.
-
-## Where the frameworks are going
-
-Survey the field and a shape emerges. LangChain and LangGraph pair graph-based orchestration with LangSmith for operations, funded to build the team that operates the platform. CrewAI and AutoGen are converging on multi-agent orchestration patterns. Google's ADK is a strong code-first framework with first-class evaluation, tuned for Gemini and Google Cloud. tRPC-Agent-Go brings a production-grade Go agent SDK — LLM, Chain, Parallel, Cycle, and Graph agents; tools; MCP and A2A; memory and RAG; evaluation; agent self-evolution; OpenTelemetry — maintained by Tencent's tRPC group and validated inside Tencent.
-
-They differ in the details, but most share two structural choices. They are an **agent SDK you run alongside your services** — the agents are a layer, and your service tier lives somewhere else and is called into. And they are **graph-centric** — you compose agents and tools into graphs and conditional workflows. That is a coherent, well-trodden approach, and for a lot of teams it is exactly right.
-
-Go Micro starts somewhere else.
-
-## Where Go Micro fits: an agent is a service
-
-Go Micro's position is a single claim: **an agent is a service.** Not a layer bolted onto a service tier — the same runtime.
-
-The reasoning is straightforward. The moment an agent has to discover services, call them, hold state, and recover from failure, it *is* a distributed system. That is precisely the problem a service framework already solves. So instead of building an agent SDK that sits next to your services, Go Micro makes agents and services the same primitives:
-
- **Every service endpoint is automatically an AI-callable tool**, derived from registry metadata. You do not wire tools into a graph; you write a service and it is already a tool, reachable over MCP.
- **An agent is a service.** It registers, is discovered, load-balances, exposes an `Agent.Chat` RPC, keeps store-backed memory, and is reachable over A2A — the same lifecycle as anything else you run.
- **Workflows are durable code paths, not a graph DSL.** Use a `flow` of checkpointed steps where the path is known; dispatch to an agent where it is not. The deterministic parts are plain, resumable Go; the dynamic parts are agents.
-
-The premise is that the line between "your services" and "your agents" is accidental complexity. Remove it, and there is less to wire, less to keep in sync, and a much shorter path from a service to an agent that uses it. The operational harness — discovery, RPC, pub/sub, durable runs, observability, deployment — is not something you assemble around the framework. It *is* the framework.
-
-This is also why Go Micro is deliberately not a graph DSL. Graphs are expressive, and for some teams that visual, declarative model is the draw. But a graph is one more thing to learn and maintain next to your services. "It is just services and durable flows" is a smaller surface to hold in your head, and it composes with everything a service already does.
-
-## A concrete contrast: tRPC-Agent-Go
-
-Because it is the closest neighbour — a serious, production Go framework — tRPC-Agent-Go makes the fork concrete. It is an agent SDK that runs alongside your tRPC services, organised around graph, chain, parallel, and cycle agents. Go Micro is one runtime where the agent *is* the service and orchestration is durable flows.
-
-We will be honest about where they are ahead: tRPC-Agent-Go ships a first-class evaluation framework, agent self-evolution, AG-UI streaming, and RAG today. Go Micro has the trace foundation (OpenTelemetry run timelines, `micro runs`) and has the verification/grader loop and richer memory on the roadmap — but if you need those right now, they are further along there, with a large team behind them. Pretending the checklists match would help no one.
-
-What Go Micro offers in return is the thing an SDK-alongside-your-services cannot: services that become tools with zero glue, agents that are first-class services, and one set of primitives — service, agent, flow — instead of a service stack plus an agent layer plus a graph runtime.
-
-## The direction we're building
-
-If scheduled, looping, work-performing agents are where this goes, then the operational harness is the thing to get right, and loops are the organising idea. Go Micro already has the agent loop, durable event-driven flows, and the trace foundation for learning. The verification loop — grade a step's output against a rubric and route failures back with feedback — is the next primitive, building on the supervised loop and retry machinery already there. Durable agent runs, streaming end to end, and richer observability are on the same line. The aim is not to win a feature checklist; it is to be the runtime where an operating agent is dependable.
-
-There is one more piece of evidence we find hard to argue with: Go Micro is increasingly built by its own loop — an autonomous improvement loop running in CI, opening and merging its own changes against a thesis. An agent harness, operated by agents, building itself. If it is good enough to do that, it is good enough to operate yours.
-
-## Open protocols, different homes
-
-None of this is winner-take-all, and it should not be. Every serious framework here speaks **MCP** for tools and **A2A** for agents. A Go Micro agent and a tRPC-Agent-Go agent can call each other; either can consume the other's tools; an ADK or LangGraph agent can plug into a Go Micro runtime over A2A, and the reverse. The protocols are the commons.
-
-So the real question is not which framework wins. It is where your agents should *live*. The answer that Go Micro is built around is that when an agent has to operate inside a real system, it is a distributed system — and the simplest place to build it is the runtime where your services already live.
-
---
-
-*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/31">&larr; How Go Micro Builds Itself</a></div>
-  <div><a href="/blog/">All Posts</a></div>
-</div>
@@ -11,13 +11,6 @@ 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/32">An Agent Is a Service: Where Agent Frameworks Are Going</a></h2>
-    <p class="meta" style="color: #666; font-size: 0.85rem;">June 30, 2026</p>
-    <p>A field guide to the agent-framework landscape — LangChain and the first wave, the two layers of a harness, the rise of loop engineering, and where the frameworks (LangGraph, ADK, CrewAI, AutoGen, tRPC-Agent-Go) diverge. And why Go Micro's answer is that an agent is a service.</p>
-    <a href="/blog/32">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/31">How Go Micro Builds Itself</a></h2>
    <p class="meta" style="color: #666; font-size: 0.85rem;">June 25, 2026</p>
@@ -31,7 +31,7 @@ your stack — the harness *is* the stack.
 | Tools | Every service endpoint is an MCP-callable tool from registry metadata — no extra code | Shipped |
 | Memory | Store-backed agent memory (`AgentMemory`), durable across restarts | Shipped |
 | Guardrails | `MaxSteps`, `LoopLimit`, `ApproveTool`, tool wrappers — enforced at the call site | Shipped |
-| Workflows | Durable flows; `micro.FlowLoop` for run-until-done | Shipped |
+| Workflows | Durable flows; `flow.Loop` for run-until-done | Shipped |
 | Planning / delegation | Built-in `plan` and `delegate` tools on every agent | Shipped |
 | Discovery & RPC | Registry + client; agents and services find and call each other | Shipped |
 | Interop | MCP (tools), A2A (agents), x402 (paid tools) | Shipped |
@@ -69,14 +69,6 @@ if err != nil {
 _ = resp
 ```

-Choose the boundary deliberately: use a durable flow when the steps are known
-(`reserve`, `charge`, `confirm`) and each step has deterministic retry/resume
-semantics. Use a checkpointed agent run when the model is deciding which tools to
-call or how many turns it needs, but the side effects of completed tool calls
-still need crash-safe resume. Flows and agents share the same `Checkpoint`
-interface, so a flow can safely dispatch to a checkpointed agent for the
-open-ended part.
-
 For human-in-the-loop runs that pause through the built-in `request_input` tool,
 resume with the operator's response:

@@ -18,11 +18,11 @@ you're done") has no natural ceiling. So a usable loop needs two things:
 1. a **stop condition** — how it decides it's done, and
 2. a **hard cap** — a guardrail that guarantees it always terminates.

-Go Micro gives you both as a flow step: `micro.FlowLoop`.
+Go Micro gives you both as a flow step: `flow.Loop`.

 ## The shape

-`micro.FlowLoop` is a `StepFunc`, so it drops into a flow's ordered, checkpointed
+`flow.Loop` is a `StepFunc`, so it drops into a flow's ordered, checkpointed
 step list like any other step. It runs a **body** step repeatedly, carrying the
 flow `State` from one pass to the next, until a stop condition fires or the
 iteration cap is hit — whichever comes first.
@@ -89,32 +89,14 @@ Agents use store-backed conversation memory by default, scoped under the agent's
 name. That makes short restarts boring: the next `Ask` reloads the retained
 history from the same store backend you already use for services and flows.
 Long-running agents can also keep model context bounded without losing useful
-prior context. If you want retrieval without summaries, enable bounded active
-context plus a durable archive of every turn:
-
-```go
-a := micro.NewAgent("conductor",
-    micro.AgentServices("task"),
-    micro.AgentProvider("anthropic"),
-    micro.AgentRetrievalMemory(40),        // active messages kept in prompt context
-    micro.AgentMemoryRecallLimit(5),       // archived turns recalled per Ask
-)
-```
-
-`AgentRetrievalMemory(activeLimit)` switches the default memory to a store-backed
-retriever. The active conversation is capped at `activeLimit`, every turn is
-archived in the same scoped store used by the agent, and future asks inject
-matching archived turns ahead of active context. The built-in ranking is
-deterministic and credential-free for CI.
-
-When you also want a rolling summary in active context, use compacting memory:
+prior context:

 ```go
 a := micro.NewAgent("conductor",
    micro.AgentServices("task"),
    micro.AgentProvider("anthropic"),
    micro.AgentCompactMemory(40, 12),      // max active messages, recent messages kept verbatim
-    micro.AgentMemoryRecallLimit(5),       // compacted turns recalled per Ask
+    micro.AgentMemoryRecallLimit(5),       // archived turns recalled per Ask
 )
 ```

@@ -123,7 +105,8 @@ deterministic compactor. Once active history grows past `maxMessages`, older
 turns move into the durable archive, a provider-neutral summary is injected into
 active context, and the newest `keepRecent` messages stay verbatim. On future
 asks, archived turns whose text matches the current request are recalled ahead of
-the active context. Teams that need embeddings or a vector database can still
+the active context. The built-in retrieval is intentionally simple and
+credential-free for CI; teams that need embeddings or a vector database can still
 provide their own `AgentMemory` implementation.

 This is harness memory, not prompt-layer orchestration: services remain the
@@ -423,5 +423,5 @@ micro server --address :9000
 ## Need Help?

 - **Issues**: [github.com/micro/go-micro/issues](https://github.com/micro/go-micro/issues)
- **Discord**: [discord.gg/G8Gk5j3uXr](https://discord.gg/G8Gk5j3uXr)
+- **Discord**: [discord.gg/WeMU5AGxD](https://discord.gg/WeMU5AGxD)
 - **Docs**: [go-micro.dev/docs](https://go-micro.dev/docs)
@@ -227,53 +227,6 @@ and an ADK agent (in any language) can call each other over A2A, and either can
 consume the other's MCP tools. A common pattern is to run Go Micro as the service
 mesh / runtime and let ADK (or any A2A agent) plug into it.

-## vs tRPC-Agent-Go
-
-[tRPC-Agent-Go](https://github.com/trpc-group/trpc-agent-go) (maintained by tRPC-Group,
-validated inside Tencent) is a production-grade Go framework for agent systems:
-LLM / Chain / Parallel / Cycle / Graph agents, function tools, MCP, A2A, AG-UI, Redis
-memory and RAG, evaluation, agent self-evolution, and OpenTelemetry. It's a serious,
-well-resourced project.
-
-They overlap heavily on agents but take a different approach. tRPC-Agent-Go is an **agent
-SDK you run alongside your services** — you compose agents and tools into graphs and
-conditional workflows, and your microservices (tRPC) live separately and are called
-into. Go Micro starts from the premise that **an agent is a service** — one runtime
-where every endpoint is automatically a tool, an agent registers and is discovered and
-load-balanced like anything else, and workflows are durable code paths rather than a
-graph DSL. The premise is that the line between "your services" and "your agents" is
-accidental complexity; remove it and there's less to wire and keep in sync.
-
-| | Go Micro | tRPC-Agent-Go |
-|---|----------|---------------|
-| **Primary unit** | A harnessed service (an agent is a service with an LLM inside) | An agent |
-| **Orchestration** | Durable `flow` steps + `Loop` — plain code paths | Graph / Chain / Parallel / Cycle agents (graph DSL) |
-| **Services as tools** | Every endpoint is automatically an MCP tool | Function tools + MCP, wired explicitly |
-| **Service runtime** | Built in — agents *are* services (registry, RPC, load balancing, pub/sub) | Runs alongside your existing service stack (tRPC) |
-| **MCP / A2A** | Both, generated from the registry | Both |
-| **Evaluation / self-evolution** | Verification loop on the roadmap; not yet first-class | First-class today |
-| **Memory / RAG** | Store-backed memory (Postgres, NATS KV, file); RAG on the roadmap | In-memory / Redis memory; RAG today |
-| **Observability** | OpenTelemetry run timelines, `micro runs` | OpenTelemetry, Langfuse examples |
-| **Backing** | Independent, community | tRPC-Group / Tencent |
-
-### When to choose tRPC-Agent-Go
- You want a graph/workflow DSL for composing agents and tools
- You're on tRPC, or want to add agents alongside an existing service stack
- You want first-class evaluation and self-evolution today, with a large team behind it
-
-### When to choose Go Micro
- You want one runtime where services, agents, and flows are the same primitives —
-  registered, discoverable, and deployed the same way
- You want your existing services to become agent tools with zero extra code
- You prefer durable flows and plain code paths over a graph DSL, in a small,
-  independent framework you can hold in your head
-
-### They interoperate
-
-Both speak **MCP** and **A2A**, so a Go Micro agent and a tRPC-Agent-Go agent can call
-each other over A2A, and either can consume the other's MCP tools. You can run Go Micro
-as the service-and-agent runtime and still reach an agent built on tRPC-Agent-Go.
-
 ## Feature Deep Dive

 ### Service Discovery
@@ -1,84 +0,0 @@
---
-layout: default
---
-
-# 0→hero reference path
-
-The 0→hero path is the maintained, no-secret reference for the Go Micro
-services → agents → workflows lifecycle. It ties the CLI inner loop and the
-runtime harness together so a contributor can prove the framework still works as
-one system, not as separate demos.
-
-Use it when you want to answer: "Can I scaffold a service, run it locally, talk
-to an agent, inspect durable work, and reach the deployment boundary without
-cloud credentials?"
-
-## What the contract covers
-
-| Boundary | Contract | CI check |
-| --- | --- | --- |
-| Scaffold | `micro new` generates a runnable service with and without MCP support. | `go test ./cmd/micro/cli/new -run TestZeroToOne -count=1` |
-| Run | `micro run` remains the local development entry point. | `go test ./cmd/micro -run TestZeroToHeroCLIBoundaries -count=1` |
-| Chat | `micro chat` remains the interactive agent entry point. | `go test ./cmd/micro -run TestZeroToHeroCLIBoundaries -count=1` |
-| Inspect | `micro inspect agent`, `micro inspect flow`, and `micro flow runs` remain discoverable for run history. | `go test ./cmd/micro -run TestZeroToHeroCLIBoundaries -count=1` |
-| Deploy | `micro deploy --dry-run` resolves deploy targets without touching remote infrastructure. | `go test ./cmd/micro/cli/deploy -run TestDeployDryRun -count=1` |
-| Runtime | Real services, agents, durable flows, store-backed history, delegation, and A2A run with only the model mocked. | `./internal/harness/zero-to-hero-ci/run.sh` and `make provider-conformance-mock` |
-
-## Run the whole no-secret path
-
-From the repository root:
-
-```sh
-make harness
-```
-
-That target runs the scaffold contract, the CLI boundary smoke tests, the
-0→hero runtime harnesses, the event-driven agent-flow harness, and mock provider
-conformance. It is intentionally deterministic: no provider key, cloud account,
-SSH access, or remote service is required.
-
-## Run focused checks while iterating
-
-Use the smaller checks when you are working on one seam:
-
-```sh
-# Scaffold → run/call contract.
-go test ./cmd/micro/cli/new -run TestZeroToOne -count=1
-
-# CLI inner-loop commands: run, chat, inspect, flow runs, deploy --dry-run.
-go test ./cmd/micro -run TestZeroToHeroCLIBoundaries -count=1
-go test ./cmd/micro/cli/deploy -run TestDeployDryRun -count=1
-
-# Durable services → agents → workflows reference scenarios.
-./internal/harness/zero-to-hero-ci/run.sh
-
-# Event-as-prompt agent flow.
-go run ./internal/harness/agent-flow
-
-# Cross-provider semantics with the deterministic mock provider.
-make provider-conformance-mock
-```
-
-## Reference scenarios
-
- [`internal/harness/plan-delegate`](https://github.com/micro/go-micro/tree/master/internal/harness/plan-delegate)
-  is the compact 0→hero scenario: real task and notify services, a conductor
-  agent, a comms agent, plan persistence, delegation, and a workflow handoff.
- [`internal/harness/universe`](https://github.com/micro/go-micro/tree/master/internal/harness/universe)
-  boots a larger mini-world: inventory, payment, order confirmation, a concierge
-  agent, durable checkpoint/resume, agent run history, flow run history, and A2A
-  reachability.
- [`internal/harness/agent-flow`](https://github.com/micro/go-micro/tree/master/internal/harness/agent-flow)
-  shows the event-driven path where a `user.created` event prompts an agent to
-  call services and complete onboarding.
-
-Together these scenarios keep the North Star executable: services expose typed
-capabilities, agents use those capabilities with memory and guardrails, and
-workflows compose the work over time.
-
-## Keeping the guide honest
-
-If you change the CLI inner loop, durable flow APIs, agent run history, or the
-provider/tool semantics, update this guide and the harness in the same PR. The
-point of 0→hero is not a polished sample app that drifts from reality; it is a
-CI-verifiable contract that the documented lifecycle still works.
@@ -95,7 +95,7 @@ publisher.Publish(ctx, &UserCreatedEvent{

 ## Get Help

- **[Discord Community](https://discord.gg/G8Gk5j3uXr)** - Chat with other users
+- **[Discord Community](https://discord.gg/WeMU5AGxD)** - Chat with other users
 - **[GitHub Issues](https://github.com/micro/go-micro/issues)** - Report bugs or request features
 - **[Documentation](https://go-micro.dev/docs/)** - Complete docs

@@ -58,4 +58,4 @@ The framework is the product. It's funded by **sponsorship** from the people and

 ## Feedback

-Open an issue or start a discussion on [GitHub](https://github.com/micro/go-micro), or join the [Discord](https://discord.gg/G8Gk5j3uXr).
+Open an issue or start a discussion on [GitHub](https://github.com/micro/go-micro), or join the [Discord](https://discord.gg/WeMU5AGxD).
@@ -271,7 +271,7 @@
      </div>
      <p class="subtitle" style="margin-top: 2.25rem;">Want to support Go Micro and put your logo here? Or running it in production and need a hand?</p>
      <div class="hero-buttons">
-        <a href="https://discord.gg/G8Gk5j3uXr" class="btn btn-secondary">Become a sponsor</a>
+        <a href="https://discord.gg/WeMU5AGxD" class="btn btn-secondary">Become a sponsor</a>
        <a href="/support" class="btn btn-primary">Commercial support</a>
      </div>
    </section>
@@ -283,7 +283,6 @@
        <div class="hero-buttons">
          <a href="/docs/getting-started.html" class="btn btn-primary">Get Started</a>
          <a href="/docs/" class="btn btn-secondary">Read the Docs</a>
-          <a href="https://discord.gg/G8Gk5j3uXr" class="btn btn-secondary">Join Discord</a>
          <a href="/blog/" class="btn btn-secondary">Blog</a>
        </div>
      </div>
@@ -116,24 +116,6 @@ func AgentLoopLimit(n int) AgentOption { return agent.LoopLimit(n) }
 // each action the agent takes.
 func AgentApproveTool(fn ApproveFunc) AgentOption { return agent.ApproveTool(fn) }

-// AgentModelCallTimeout sets the timeout for each provider Generate call.
-func AgentModelCallTimeout(d time.Duration) AgentOption { return agent.ModelCallTimeout(d) }
-
-// AgentModelRetry sets the provider retry budget and backoff for transient failures.
-func AgentModelRetry(maxAttempts int, backoff time.Duration) AgentOption {
-	return agent.ModelRetry(maxAttempts, backoff)
-}
-
-// AgentToolCallTimeout sets the timeout for each agent tool execution.
-func AgentToolCallTimeout(d time.Duration) AgentOption { return agent.ToolCallTimeout(d) }
-
-// AgentToolRetry sets the tool retry budget and backoff for transient failures.
-// Attempts include the first call. Retries are opt-in because tools can have
-// side effects; keep handlers idempotent before enabling this.
-func AgentToolRetry(maxAttempts int, backoff time.Duration) AgentOption {
-	return agent.ToolRetry(maxAttempts, backoff)
-}
-
 // Memory is an agent's pluggable conversation memory.
 type Memory = agent.Memory

@@ -146,12 +128,6 @@ type ToolFunc = agent.ToolFunc
 // NewMemory returns the default store-backed agent memory.
 func NewMemory(s store.Store, key string, limit int) Memory { return agent.NewMemory(s, key, limit) }

-// NewRetrievalMemory returns store-backed memory with bounded active context
-// and durable retrieval over every prior turn.
-func NewRetrievalMemory(s store.Store, key string, activeLimit int) Memory {
-	return agent.NewRetrievalMemory(s, key, activeLimit)
-}
-
 // NewCompactingMemory returns store-backed memory with deterministic
 // summarization and retrieval controls.
 func NewCompactingMemory(s store.Store, key string, maxMessages, keepRecent int) Memory {
@@ -164,10 +140,6 @@ func NewInMemory(limit int) Memory { return agent.NewInMemory(limit) }
 // AgentMemory sets the agent's conversation memory (default: store-backed).
 func AgentMemory(m Memory) AgentOption { return agent.WithMemory(m) }

-// AgentRetrievalMemory enables deterministic default-memory retrieval without
-// compaction; activeLimit bounds active context while every turn is archived.
-func AgentRetrievalMemory(activeLimit int) AgentOption { return agent.RetrievalMemory(activeLimit) }
-
 // AgentCompactMemory enables deterministic default-memory compaction and
 // retrieval for long-running agents.
 func AgentCompactMemory(maxMessages, keepRecent int) AgentOption {