Inspector

The Inspector is the visual operator console for any Neotoma instance. It runs alongside the Neotoma server (locally at http://localhost:3080/inspector, or on a hosted Neotoma deployment) and is the fastest way to see exactly what your agents have written, why, and on whose authority.

Where the CLI and MCP surface let agents write to Neotoma, the Inspector lets you read, audit, and correct that state, every entity, every observation, every relationship, every source artifact, every signed agent, every conversation turn, without writing SQL.

What the Inspector is for

Neotoma's value comes from a single shared, versioned graph of state. Once agents start writing, three questions immediately matter:

• What did they write? Browse entities, observations, sources, relationships, and timeline events with full filters and pagination.
• Why is the snapshot what it is? Drill into per-field provenance, which observation won, when, from which agent, citing which source row.
• Was it written on real authority? Inspect AAuth trust tiers, JWT subjects, hardware attestation envelopes, and operator allowlists per row.

Because Neotoma never overwrites observations, the Inspector also acts as a forensic tool: every value you see can be traced back to the observation, source, and agent that produced it, and corrections layer on top without erasing history.

How to open it

The Inspector is bundled with the Neotoma server and served by the same process as the API:

# Start (or confirm) the local API
neotoma api start --env dev

# Open the Inspector
open http://localhost:3080/inspector

For hosted Neotoma deployments, the Inspector is reachable at https://<your-neotoma-host>/inspector. The Inspector respects the same authentication contract as the API: bearer tokens, user_id scope, and AAuth-attributed writes flow through unchanged. See AAuth for the attribution contract surfaced in every Inspector list.

Sections

Each subpage below maps directly to a section of the Inspector application and shows representative UI:

• Dashboard & health , top-level stats, type breakdown, system health, attribution coverage.
• Entities , filter, search, and inspect entity snapshots; per-field provenance and multi-field corrections.
• Observations & sources , the immutable write log and the raw artifacts behind it.
• Relationships & graph , typed edges, neighborhood graph explorer, traversal.
• Schemas , registered entity types, fields, identity rules, schema evolution.
• Timeline & interpretations , event stream, replays, derived interpretation entities.
• Conversations & turns , agent_message rows reconstructed into per-conversation transcripts.
• Agents, AAuth & grants , per-agent rosters, trust tier, attestation envelopes, grant policies.
• Search , ⌘K global identifier and full-text search across every record type, with ranking and result-kind details.
• Feedback , in-app route /feedback (top-level sidebar, not under Settings): submissions, PII redaction preview, and status feed.
• Settings , /settings instance configuration. Drill in for Connection, Attribution policy, Retention, and Theme & accessibility.

Tech stack

Inspector is a standalone React 19 + Vite 6 single-page application served from the Neotoma server. It uses Tailwind CSS for styling, TanStack Query for data fetching, TanStack Table for list views, Recharts for charts, and @xyflow/react for the graph explorer. Every panel reads from the same REST endpoints documented under REST API , there is no Inspector-specific backend.

Read-mostly, with safe corrections

The Inspector is read-mostly by design. Where it does write, it follows the same rules as any other client:

• Field-level corrections add a new observation; they never mutate or delete the prior one.
• Relationship creates and merges go through the same /create_relationship and /merge_entities endpoints used by the MCP and CLI.
• Inspector-originated writes are themselves attributed, clientInfo.name is set to inspector-ui and (when configured) signed via AAuth, so you can audit operator actions in the same surfaces as agent actions.