AgentCore, OTel/OpenInference, and the Agent Training Loop 2026

See also (wiki): wiki/agent-operations-observability.md · wiki/semantic-observability.md · wiki/mlops-ai-platform-engineering.md · wiki/model-risk-management.md

Source credibility: MEDIUM-HIGH. Primary sources are current Amazon Bedrock AgentCore docs, OpenInference semantic conventions, Prime Intellect PRIME-RL/Verifiers docs, Unsloth docs, LLaMA-Factory docs, and Axolotl GRPO docs. This page maps how the systems fit together; it does not claim a locally verified end-to-end training run.

Executive Summary

AgentCore native features, OTel/OpenInference, and training stacks solve different problems:

• AgentCore is the managed runtime/control plane: runtime isolation, identity, memory, gateway/tools, browser/code tools, policy, observability, and evaluations.
• OpenTelemetry is the trace transport and correlation layer: trace_id, span_id, parent_span_id, W3C traceparent, collectors, and export pipelines.
• AI semantic conventions are a moving choice, not a single settled layer. OpenInference gives Phoenix/Arize-style LLM, TOOL, RETRIEVER, RERANKER, AGENT, GUARDRAIL, EVALUATOR, and PROMPT span semantics. OTel GenAI gives gen_ai.* attributes for model/client, agent/framework, tool, event, and metric telemetry. MCP now has its own trace-context and semantic-convention lane for protocol/tool spans. Pin the semantic-convention version and record whether OTEL_SEMCONV_STABILITY_OPT_IN included gen_ai_latest_experimental; otherwise a collector/backend upgrade can make the same run render differently.
• Unsloth and LLaMA-Factory are model adaptation stacks: SFT, LoRA/QLoRA, DPO, ORPO, KTO, PPO, GRPO-style workflows, and tool-calling/local-model training formats.
• Prime Intellect / Verifiers / PRIME-RL is an environment and rollout layer for training/evaluating agents with verifiable rewards, async rollouts, multi-turn/tool-use environments, and large-scale RL infrastructure.

The durable architecture is not “send traces directly to fine-tuning.” It is:

AgentCore / local agent runtime
  -> native logs + OTel traces with OpenInference, OTel GenAI, or MCP semantics
  -> warehouse tables: turns, tool_calls, artifacts, evaluations, rollouts
  -> curated datasets: SFT rows, preference pairs, verifier environments
  -> training stacks: Unsloth, LLaMA-Factory, Axolotl, PRIME-RL, AgentCore RL Toolkit
  -> benchmark/eval promotion gate
  -> production rollout with new prompt/model/tool policy version

Layer Map

How AgentCore Native Features Fit

AgentCore gives the production system a managed spine:

AgentCore native observability helps, but it does not remove the need for OpenInference/warehouse normalization. The reason is simple: a training example needs lineage, redaction, labels, splits, and legal review. A trace dashboard does not decide whether a chat is training-safe.

OpenTelemetry, OpenInference, and MCP Mapping for Training

Version every emitted AI semantic layer:

{
  "trace_id": "trace_hash",
  "span_id": "span_hash",
  "ai_semantic_convention": "otel_genai",
  "ai_semantic_convention_version": "1.41.1",
  "semconv_stability_opt_in": "gen_ai_latest_experimental",
  "instrumentation_name": "strands-agents",
  "instrumentation_version": "x.y.z"
}

Minimum join keys:

{
  "rollout_id": "rollout_hash",
  "trace_id": "trace_hash",
  "span_id": "span_hash",
  "turn_id": "turn_hash",
  "tool_call_id": "tool_hash",
  "artifact_id": "artifact_hash",
  "eval_id": "eval_hash",
  "memory_event_id": "memory_hash",
  "context_event_id": "context_hash",
  "compaction_id": "compaction_hash",
  "dataset_example_id": "example_hash",
  "prompt_version": "prompt_v12",
  "model_artifact_id": "adapter_or_checkpoint_hash",
  "policy_version": "policy_v4"
}

How Traces Become Training Data

Unsloth and LLaMA-Factory Fit

Unsloth is strongest when the goal is fast local or single/few-GPU adaptation: LoRA/QLoRA, SFT, tool-calling format tuning, DPO/ORPO/KTO, and GRPO-style reasoning/RL workflows. It is useful after the warehouse has produced training-safe rows.

LLaMA-Factory is a broader training workbench with YAML/CLI training configs for pretraining, SFT, reward modeling, PPO, DPO, KTO, ORPO, and related preference losses. It is useful when a team wants a repeatable training recipe and compatibility across many open models.

Neither tool replaces AgentCore observability. They consume curated datasets derived from traces and evals.

Example conversion for a domain YAML generator:

{
  "messages": [
    { "role": "system", "content": "Generate only valid policy YAML for schema v3." },
    { "role": "user", "content": "Create policy for case class A with controls X and Y." },
    { "role": "assistant", "content": "kind: Policy\nversion: v3\n..." }
  ],
  "metadata": {
    "source_trace_id": "trace_hash",
    "source_artifact_id": "artifact_hash",
    "schema_name": "policy_yaml_v3",
    "validator_status": "passed",
    "redaction_version": "stateofai-redaction-v1"
  }
}

For preference training:

{
  "prompt": "Create policy YAML for case class A with controls X and Y.",
  "chosen": "kind: Policy\nversion: v3\n...",
  "rejected": "Here is the YAML you asked for:\n```yaml\n...",
  "metadata": {
    "failure_code": "extraneous_markdown_fence",
    "judge": "deterministic_yaml_validator",
    "source_rollout_id": "rollout_hash"
  }
}

Prime Intellect / Verifiers / PRIME-RL Fit

Prime Intellect’s key contribution is the environment layer. Its docs describe Verifiers environments as packages that can drive RL training, standalone evaluation, and synthetic data generation. PRIME-RL is positioned as an async RL trainer for multi-turn/tool-use environments, LoRA adapters, large-scale multi-node training, MoE models, SFT, online distillation, and RL.

This pattern is bigger than one vendor. The converging abstraction is an environment package: the same package can define task generation, reset state, tool access, validators/rewards, eval metrics, synthetic-data generation, and rollout capture. For agent training, that environment is the contract that turns traces into repeatable experiments. Without it, RLVR/GRPO data is just a pile of scored transcripts with weak replay value.

That maps cleanly to this observability standard:

The important architecture decision: if an AgentCore-hosted agent is used to generate rollouts for PRIME-RL or a Verifiers environment, pass the same rollout_id and W3C traceparent through AgentCore, OTel, the environment, and the trainer. Otherwise, the training job will know reward, but the observability system will not know why the reward happened.

SOTA Training Methods in This Context

For corporate agent systems, the recommended order is:

1. deterministic evals and golden/canary sets;
2. prompt/tool-policy optimization;
3. retrieval and schema validation fixes;
4. SFT on validated examples;
5. preference optimization for style/safety/selection;
6. RLVR/GRPO-family methods only where rewards are verifiable and environments are stable.

The reward caveat matters more than the algorithm label. RLVR is strongest when the outcome is externally checkable: unit tests, math answers, executable code, schema-valid YAML, SQL result equivalence, policy-rule checks, or exact tool argument validation. Most corporate agent workflows are multidimensional: helpfulness, policy appropriateness, business judgment, source sufficiency, tone, latency, cost, and authorization all matter at once. In those workflows, reward design and evaluator calibration are the bottleneck. Switching from GRPO to a newer variant does not fix a bad or subjective reward function.

Self-Improving Curriculum Loop

Retrospective mining finds repeated successes and failures in existing traces. The next rung is closed-loop curriculum generation:

failure clusters + weak skills
  -> generate calibrated tasks
  -> run agent/model in an environment package
  -> verify with deterministic or rubric-backed rewards
  -> add hard-but-valid cases to golden/canary sets
  -> train or prompt-optimize
  -> re-run held-out evals before promotion

This is useful for domain YAML generation because the environment can synthesize schema-constrained cases, run validators, and emit exact failure codes. It is dangerous for subjective enterprise workflows unless task generation, reward models, and held-out benchmarks are separated to avoid reward hacking and eval leakage.

Practical Architecture

Production / lab agent
  AgentCore Runtime or local runner
  AgentCore Gateway / MCP / browser / code tools
  AgentCore Memory / policy / identity
        |
        v
  OTel + OpenInference spans
        |
        v
  Raw vault + warehouse
  raw_events, agent_spans, turns, tool_calls, artifacts, evaluations
        |
        +--> Phoenix/LangSmith/Langfuse/Braintrust/Weave for review
        |
        +--> dataset builder
              SFT rows, preference pairs, verifier environments, golden sets
                    |
                    +--> Unsloth / LLaMA-Factory / Axolotl
                    +--> Prime-RL / Verifiers / AgentCore RL Toolkit
                    |
                    v
              model/prompt/tool-policy candidate
                    |
                    v
              benchmark gate -> production rollout

Hard Boundaries

• Do not use AgentCore Observability as the training dataset. Use it as a trace and debugging source feeding a governed curation layer.
• Do not use OpenInference spans as the only training format. Convert spans into SFT/preference/RL examples with labels, splits, lineage, and redaction.
• Do not fine-tune before deterministic validators and prompt optimization have been tried for schema-bound tasks.
• Do not run RL unless the reward is stable, cheap enough, and resistant to reward hacking.
• Do not ignore model architecture: small LoRA adapters, MoE RL, long-context GRPO, and local tool-calling models have different data and compute needs.

Sources

• AgentCore observability configuration: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/observability-configure.html
• AgentCore FAQs: https://aws.amazon.com/bedrock/agentcore/faqs/
• AgentCore release notes: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/release-notes.html
• AWS AgentOps with AgentCore: https://aws.amazon.com/blogs/machine-learning/agentops-operationalize-agentic-ai-at-scale-with-amazon-bedrock-agentcore/
• AgentCore RL Toolkit: https://pypi.org/project/agentcore-rl-toolkit/
• OpenInference semantic conventions: https://arize-ai.github.io/openinference/spec/semantic_conventions.html
• OpenTelemetry GenAI semantic conventions: https://opentelemetry.io/docs/specs/semconv/gen-ai/
• MCP OTel trace-context SEP: https://modelcontextprotocol.io/seps/414-request-meta
• Phoenix tracing docs: https://arize.com/docs/phoenix/tracing/overview
• Unsloth RL guide: https://docs.unsloth.ai/get-started/reinforcement-learning-rl-guide
• Unsloth DPO/ORPO/KTO docs: https://docs.unsloth.ai/basics/reasoning-grpo-and-rl/reinforcement-learning-dpo-orpo-and-kto
• Unsloth tool-calling guide: https://unsloth.ai/docs/basics/tool-calling-guide
• LLaMA-Factory SFT docs: https://llamafactory.readthedocs.io/en/latest/getting_started/sft.html
• LLaMA-Factory trainers: https://llamafactory.readthedocs.io/en/latest/advanced/trainers.html
• LLaMA-Factory arguments: https://llamafactory.readthedocs.io/en/latest/advanced/arguments.html
• Axolotl GRPO docs: https://docs.axolotl.ai/docs/grpo.html
• Prime Intellect PRIME-RL environments: https://docs.primeintellect.ai/prime-rl/environments
• Prime Intellect Verifiers training: https://docs.primeintellect.ai/verifiers/training
• Prime Intellect environment model: https://docs.primeintellect.ai/hosted-training/environment-model
• Prime-RL GitHub: https://github.com/PrimeIntellect-ai/prime-rl
• Verifiers GitHub: https://github.com/PrimeIntellect-ai/verifiers
• DAPO paper card: https://huggingface.co/papers/2503.14476
• GSPO paper: https://arxiv.org/abs/2507.18071
• INTELLECT-2 technical report: https://arxiv.org/abs/2505.07291
• INTELLECT-3 technical report: https://arxiv.org/abs/2512.16144
• Existing observability standard: /technical/19-agent-frameworks/agent-observability-format-standard-2026/index.md

Brandon Sneider | brandon@brandonsneider.com June 2026