Agent Observability logo

Agent Observability

Community
seb1n
agent-observability

Design privacy-aware observability for AI agents using traces, spans, structured events, metrics, cost attribution, dashboards, alerts, and investigation workflows. Use when instrumenting an agent, debugging intermittent tool or model failures, defining service-level objectives, analyzing latency or spend, auditing agent decisions, or preparing production monitoring.

Overview

Publisherseb1n
Repositoryawesome-ai-agent-skills
Skill nameagent-observability
Stars
188
Forks
35
Bundled files
3
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by seb1n on GitHub. Read the source before you install it.

Installation

Install the Agent Observability AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/seb1n/awesome-ai-agent-skills.git /tmp/awesome-ai-agent-skills
mkdir -p .claude/skills
cp -r /tmp/awesome-ai-agent-skills/agent-engineering/agent-observability .claude/skills/agent-observability
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Agent Observability in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Agent Observability on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Agent Observability is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Agent Observability

Make agent behavior explainable from request entry through model, retrieval, tool, handoff, and response spans.

Use when

  • Add telemetry to a new or existing agent workflow.
  • Diagnose slow, costly, incorrect, looping, or failed executions.
  • Define dashboards, alerts, service-level indicators, or audit evidence.
  • Standardize traces across models, tools, and orchestration frameworks.

Inputs

Collect the workflow graph, runtime boundaries, incident questions, traffic and failure expectations, telemetry stack, data classification, retention policy, sampling limits, and owners. State what cannot be observed.

Output contract

Produce:

  1. An observability objective and system boundary.
  2. A trace and event schema with identifiers, span taxonomy, attributes, and redaction rules.
  3. Metrics with definitions, units, dimensions, and ownership.
  4. Dashboard and alert specifications tied to user impact.
  5. A sampling, retention, access, and cost plan.
  6. An investigation runbook and instrumentation verification results.

Workflow

  1. Start with operational questions such as “Which tool causes timeouts?” or “Why did cost per resolved task rise?” Do not collect fields without a decision use.
  2. Define one trace per user-visible attempt. Create spans for model calls, retrieval, tools, handoffs, approvals, retries, and final validation. Preserve parent-child relationships and propagate a correlation identifier across queues.
  3. Record stable semantic fields. Include version identifiers, status, timing, token and cost measures, retry counts, tool names, policy outcomes, and evaluation tags when available. Read trace-schema.md before defining attributes.
  4. Separate content from metadata. Default to content-free telemetry; allow prompt or response capture only through explicit authorization, redaction, access controls, and retention limits.
  5. Derive a small set of service indicators: task success, critical-policy violations, end-to-end latency, tool failure rate, escalation rate, and cost per completed task. Define denominators and treatment of cancellations and timeouts.
  6. Build dashboards from user outcome to dependency detail. Alert on actionable sustained impact, not individual noisy spans, and attach an owner and runbook.
  7. Control cardinality, sampling, and storage cost. Retain all critical failures when permitted; use head or tail sampling for normal traffic without losing rare error classes.
  8. Test trace propagation, redaction, retry linkage, clock handling, and degraded telemetry behavior before relying on the data.

Use python3 scripts/summarize_traces.py spans.jsonl for a content-free structural and health summary of normalized spans. It exits 1 for missing parents, a root count other than one, parent cycles, or disconnected components. Add --strict to also exit 1 when likely content-, personal-data-, secret-, or credential-bearing fields are found. Add --output summary.json for an atomic file write; the destination must be a new path or regular file and cannot alias the input through spelling, resolution, a symlink, or a hard link. Findings include field paths and reason classes, never suspected values.

Safety and permissions

  • Never record secrets, authentication tokens, raw credentials, payment data, or unapproved personal data.
  • Do not enable production capture, change retention, export telemetry, or widen access without authorization.
  • Restrict raw traces by least privilege and log access to sensitive telemetry.
  • Do not let instrumentation failures block the user path unless a mandated audit control requires fail-closed behavior.
  • Treat traces as partial evidence: absent telemetry does not prove an action did not occur.

Verification

  • Follow a synthetic request end to end and confirm every expected span shares one trace identifier, has exactly one root, and forms one acyclic connected parent graph.
  • Trigger a tool error, timeout, retry, refusal, and approval path; verify statuses and parentage.
  • Search emitted telemetry for seeded secrets and personal-data canaries.
  • Recalculate dashboard metrics from raw spans and confirm units, denominators, and time windows.
  • Verify alerts name an owner, include diagnostic context, and avoid high-cardinality dimensions.

Failure handling

  • If trace propagation breaks, preserve local logs with correlation fields and mark cross-service conclusions as incomplete.
  • If timestamps are unreliable, prefer monotonic durations within a process and avoid false cross-host ordering.
  • If telemetry volume exceeds budget, reduce verbose attributes and normal-traffic sampling before dropping critical errors.
  • If sensitive content is found, stop capture, restrict access, follow the incident policy, and purge only with authorized retention owners.

Example

For “find why the research agent became slower after a release,” compare version-tagged end-to-end traces, slice p95 latency by retrieval, model, and browser-tool spans, inspect retries and queue delay, verify sampling did not change, correlate the regression with deployment time, and return the responsible stage, affected cohort, evidence limits, and a monitored remediation.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Agent Observability AI skill do?

Design privacy-aware observability for AI agents using traces, spans, structured events, metrics, cost attribution, dashboards, alerts, and investigation workflows. Use when instrumenting an agent, debugging intermittent tool or model failures, defining service-level objectives, analyzing latency or spend, auditing agent decisions, or preparing production monitoring.

Why use Agent Observability on TypingMind?

Because you install it once and use it with any model. Agent Observability is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Agent Observability in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/seb1n/awesome-ai-agent-skills/tree/main/agent-engineering/agent-observability. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Agent Observability?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Agent Observability?

As many as you like. As long as a model supports skills, you can use Agent Observability with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Agent Observability AI skill free?

Yes. It is published on GitHub by seb1n under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇