Agent Inspector

Cognitive-level observability for agent operations

The Agent Inspector shows what an agent decided, why it decided it, and what happened as a result. Unlike protocol-level inspectors that display raw frames and HTTP traffic, the Agent Inspector presents the decision layer: goals, discoveries, plans, policy enforcement, costs, and memory operations.

How It Differs from Other Inspectors

DataGrout provides three free inspection tools. Each operates at a different level.

Inspector Level Shows
MCP Inspector Protocol Raw MCP frames, SSE streams, JSON-RPC payloads
JSONRPC Inspector Transport HTTP requests and responses, headers, latency
Agent Inspector Cognitive Decisions, reasoning, policies, economics, memory

Use the MCP Inspector to debug connection and protocol issues. Use the JSONRPC Inspector to debug HTTP transport. Use the Agent Inspector to understand agent behavior.

Views

Decision Trace

Follow an agent’s reasoning from goal to execution.

  • Goal received – the natural language objective the agent started with.
  • Tools discovered – which tools the discovery engine found and ranked.
  • Plan selected – the workflow chosen from the candidate plans, with the selection rationale.
  • CTC issued – whether a Cognitive Trust Certificate was minted and what assurances it contains.
  • Execution sequence – each step as it ran, with inputs, outputs, and status.

Economic View

Track credit consumption across an agent session.

  • Credits estimated vs. actual per step – see where estimates were accurate and where they diverged.
  • Cumulative spend – running total across all steps in the session.
  • Budget remaining – how much of the configured budget is left.
  • Cache hits – which results were served from cache instead of re-executing, and the credits saved.

Governance View

See which policies were enforced during the session.

  • Semantic Guards fired – which guard rules evaluated and whether they passed or blocked.
  • Data redacted – which fields were masked, with the strategy applied (email, phone, SSN, etc.).
  • Policies applied – which server and integration policies were active, and how the cascade resolved.

Memory View

Inspect the facts an agent read from or wrote to Logic Cells during the session.

  • Facts read – data retrieved from persistent memory and used in decision-making.
  • Facts written – new data committed to memory as a result of the session.
  • Cell references – which Logic Cells were accessed.

Performance View

Latency and resource consumption per step.

  • Latency per step – wall-clock time for each tool call, including discovery and policy evaluation overhead.
  • Cache hit rates – percentage of calls served from cache.
  • Token usage – tokens consumed by any intelligence layer operations (discovery, refraction, chart generation).

How to Access

The Agent Inspector is a free public utility. Access it from the DataGrout dashboard alongside the MCP Inspector and JSONRPC Inspector.

No additional configuration is required. The Agent Inspector reads from the same session data that powers the Runs view, presented through the cognitive lens instead of the protocol lens.

Use Cases

Debugging Agent Behavior

An agent chose the wrong tool or produced unexpected output. Open the Decision Trace to see which tools were discovered, why the plan was selected, and whether any guards modified the outcome.

Optimizing Costs

Credit spend is higher than expected. Open the Economic View to see per-step costs, identify expensive operations, and find opportunities to use cached results or skills.

Auditing Governance

A compliance review requires proof that policies were enforced. Open the Governance View to show which guards fired, what was redacted, and which policy cascade applied.

Understanding Memory

An agent’s behavior changed between sessions. Open the Memory View to see what facts were read from Logic Cells and whether prior session data influenced the current decision.

Profiling Performance

A workflow is slower than expected. Open the Performance View to identify the slowest steps and determine whether the bottleneck is in discovery, policy evaluation, or upstream API latency.

Related