AgentTel MCP server
2026년 11월 14일 커밋OpenTelemetry에 구조화된 컨텍스트를 추가하여 AI agent가 운영 중인 인시던트를 자율적으로 진단하고, 추론하며, 해결할 수 있도록 지원합니다.
다른 이름 AgentTel/agenttel-sdk
- 스타
- 11
- Tools
- 2
- 다운로드, 30일
- —
- 최신 버전
- —
- 마지막 커밋
- 2026년 11월 14일
- 라이선스
- Apache-2.0
AgentTel MCP란?
OpenTelemetry에 구조화된 컨텍스트를 추가하여 AI agent가 운영 중인 인시던트를 자율적으로 진단하고, 추론하며, 해결할 수 있도록 지원합니다. 2개 도구를 제공합니다. 예: agenttel, agenttel-instrument.
프로젝트 README에서 생성된 요약
AgentTel MCP server 정보
AgentTel은 표준 관측성과 자율 AI agent 사이의 간극을 메우기 위해 설계된 특화된 인스트루멘테이션 레이어를 제공합니다. OpenTelemetry 데이터에 구조화된 컨텍스트를 추가함으로써, agent가 단순한 모니터링을 넘어 능동적인 진단 및 복구 단계로 나아갈 수 있도록 합니다. 이 시스템은 JVM 백엔드, Go, Node.js, Python 및 브라우저 프론트엔드를 포함한 다양한 환경에서 작동합니다. 서비스 토폴로지, P50 지연 시간과 같은 운영 베이스라인, 재시도 가능 여부 또는 runbook URL과 같은 의사결정 속성 등 핵심 메타데이터를 추가합니다.
개발자는 텔레메트리를 실행 가능한 도구로 노출하는 MCP server를 통해 운영 시스템과 상호작용할 수 있습니다. 툴킷에는 IDE에서 자동 설정을 위한 인스트루멘테이션 agent와 Spring AI 또는 LangChain4j와 같은 프레임워크를 사용하는 GenAI 워크로드에 대한 특화된 지원이 포함됩니다. 통합 방식은 유연하여, 광범위한 코드 변경 없이도 프로그래밍 방식의 구현, 어노테이션 또는 YAML 설정을 지원합니다. 이러한 설정을 통해 AI 클라이언트는 기록된 OTel span을 통해 전체 감사 추적(audit trail)을 유지하면서 실시간 시스템 상태를 쿼리하고 복구 작업을 실행할 수 있습니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
AgentTel MCP 도구 2
README에서 감지됨agenttelagenttel-instrument
| agenttel | — | |
| agenttel-instrument | — |
자동 검사
2026년 11월 14일에 실행됨전체 보고서 →아직 인증되지 않았습니다. 서버는 80점 이상의 점수, 심각한 결함 없음, 그리고 검사에 충분한 데이터를 갖추어야 합니다. 검사 방식 · 점수를 높이기 위해 수정할 항목
- 소스 저장소 연결 및 접근 가능agenttel/agenttel-sdk is public and reachablegithub.com/agenttel/agenttel-sdk ↗통과
- 패키지가 이 저장소를 소스로 명시검사되지 않음
- 빌드 출처(Sigstore 증명)검사되지 않음
- 오픈 소스 라이선스 (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗통과
- 최근 1년 내 커밋 또는 릴리스Last commit or release 2026-11-11github.com/agenttel/agenttel-sdk ↗통과
- OpenSSF Scorecard검사되지 않음
- 패키지 이름이 인기 패키지와 유사하지 않음검사되지 않음
- 패키지 및 해당 종속성에 중요한 보안 권고 없음검사되지 않음
- 모델에 대한 숨겨진 지침 없음2 tool descriptions and the README read; no override phrases, credential paths or hidden characters통과
- 파괴적인 도구에 라벨 표시됨No tool named like delete, drop or exec통과
- 원격 엔드포인트가 MCP 핸드셰이크에 응답검사되지 않음
README
GitHub에서 보기AgentTel enriches OpenTelemetry telemetry with the structured context AI agents need to autonomously diagnose, reason about, and resolve production incidents — without human interpretation of dashboards. Works across the full stack: JVM backends (Java, Kotlin, Scala), Go backends, Node.js/TypeScript backends, Python backends (FastAPI, Django, Flask), and browser frontends (TypeScript/JavaScript).
Standard observability answers "What happened?" AgentTel adds "What does an AI agent need to know to act on this?"
The Problem
Modern observability tools generate massive volumes of telemetry — traces, metrics, logs — optimized for human consumption through dashboards and alert rules. AI agents tasked with autonomous incident response face critical gaps:
- No behavioral context — Spans lack baselines, so agents can't distinguish normal from anomalous
- No topology awareness — Agents don't know which services are critical, who owns them, or what depends on what
- No decision metadata — Is this operation retryable? Is there a fallback? What's the runbook?
- No actionable interface — Agents can read telemetry but can't query live system state or execute remediation
AgentTel closes these gaps at the instrumentation layer.
Design Philosophy
Core principle: telemetry should carry enough context for AI agents to reason and act autonomously.
AgentTel enriches telemetry at three levels — all configurable via YAML, no code changes required:
| Level | Where | What | Example |
|---|---|---|---|
| Topology | OTel Resource (once per service) | Service identity, ownership, dependencies | team, tier, on-call channel |
| Baselines | Span attributes (per operation) | What "normal" looks like | P50/P99 latency, error rate |
| Decisions | Span attributes (per operation) | What an agent is allowed to do | retryable, runbook URL, escalation level |
Topology is set once on the OTel Resource and automatically associated with all telemetry by the SDK. Baselines and decision metadata are attached per-operation on spans. This avoids redundant data on every span while ensuring agents always have the full context.
Quick Demo
Try AgentTel in one command — starts a demo payment service with OTel Collector and Jaeger:
cd examples/spring-boot-example
docker compose -f docker/docker-compose.yml up --build
Then open Jaeger to see enriched traces, Swagger UI for the API, and MCP Tool Docs for the agent interface.
What AgentTel Provides
Enriched Telemetry (agenttel-core)
Every span is automatically enriched with agent-actionable attributes:
| Category | Attributes | Purpose |
|---|---|---|
| Topology | agenttel.topology.team, tier, domain, dependencies |
Service identity and dependency graph |
| Baselines | agenttel.baseline.latency_p50_ms, error_rate, source |
What "normal" looks like for each operation |
| Decisions | agenttel.decision.retryable, idempotent, runbook_url, escalation_level |
What an agent is allowed to do |
| Anomalies | agenttel.anomaly.detected, pattern, score |
Real-time deviation detection |
| SLOs | agenttel.slo.budget_remaining, burn_rate |
Error budget consumption tracking |
Agent Interface Layer (agenttel-agent)
A complete toolkit for AI agent interaction with production systems:
| Component | Description |
|---|---|
| MCP Server | JSON-RPC server implementing the Model Context Protocol — exposes telemetry as tools AI agents can call |
| Health Aggregation | Real-time service health from span data with operation-level and dependency-level metrics |
| Incident Context | Structured incident packages: what's happening, what changed, what's affected, what to do |
| Remediation Framework | Registry of executable remediation actions with approval workflows |
| Action Tracking | Every agent decision and action recorded as OTel spans for full auditability |
| Context Formatters | Prompt-optimized output formats (compact, full, JSON) tuned for LLM context windows |
Frontend Telemetry (agenttel-web)
Browser SDK for agent-ready frontend observability:
| Feature | Description |
|---|---|
| Auto-Instrumentation | Page loads (Navigation Timing API), SPA navigation, fetch/XMLHttpRequest interception, click/submit interactions, JavaScript errors |
| Journey Tracking | Multi-step user funnel tracking with completion rates, abandonment detection, and duration baselines |
| Anomaly Detection | Client-side pattern detection — rage clicks, API failure cascades, slow page loads, error loops, funnel drop-offs |
| Cross-Stack Correlation | W3C Trace Context injection on all outgoing requests; backend trace ID extraction from responses |
| Route Baselines | Per-route configuration of expected page load times, API response times, error rates, and business criticality |
| Decision Metadata | Escalation levels, runbook URLs, retry policies, and fallback pages per route |
Instrumentation Agent (agenttel-instrument)
IDE-integrated MCP server for automated instrumentation setup:
| Tool | Description |
|---|---|
analyze_codebase |
Scans Java/Spring Boot source code — detects endpoints, dependencies, and framework |
instrument_backend |
Generates backend config — Gradle/Maven dependencies, annotations, agenttel.yml |
instrument_frontend |
Generates frontend config — React route detection, criticality inference, SDK initialization |
validate_instrumentation |
Validates agenttel.yml completeness against source code |
suggest_improvements |
Analyzes config and suggests fixes — missing baselines, uncovered endpoints, stale thresholds |
apply_improvements |
Auto-applies low-risk improvements using live health data; flags high-risk items for review |
GenAI Instrumentation (agenttel-genai)
Full observability for AI/ML workloads on the JVM:
| Framework | Approach | Coverage |
|---|---|---|
| Spring AI | SpanProcessor enrichment of existing Micrometer spans | Framework tag, cost calculation |
| LangChain4j | Decorator-based full instrumentation | Chat, embeddings, RAG retrieval |
| Anthropic SDK | Client wrapper | Messages API with token/cost tracking |
| OpenAI SDK | Client wrapper | Chat completions with token/cost tracking |
| AWS Bedrock | Client wrapper | Converse API with token/cost tracking |
Agent Observability (agenttel-agentic)
Full lifecycle tracing for AI agents with 70+ semantic attributes:
| Feature | Description |
|---|---|
| Invocation Lifecycle | Goal, status, step count, max steps for each agent execution |
| Reasoning Steps | Thought, action, observation, evaluation, revision tracking |
| Tool Calls | Tool name, success/error/timeout status per call |
| Task Decomposition | Nested task breakdown with depth and parent tracking |
| Orchestration Patterns | Sequential, parallel, evaluator-optimizer, handoff, ReAct, orchestrator-workers |
| Cost Aggregation | Automatic LLM cost rollup from GenAI spans to agent sessions |
| Guardrails | Block, warn, log, escalate actions with named guardrails |
| Human Checkpoints | Approval, feedback, correction gates with wait time tracking |
| Loop Detection | Detects stuck reasoning loops (identical tool calls) |
| Quality Signals | Goal achievement, human interventions, eval scores |
| RAG Pipeline | Retriever and reranker spans with relevance scoring |
| Error Classification | Source (LLM/tool/agent/guardrail/timeout/network), retryability |
Three integration styles — programmatic, annotation, or YAML config:
Programmatic:
AgentTracer tracer = AgentTracer.create(openTelemetry)
.agentName("incident-responder")
.agentType(AgentType.SINGLE)
.build();
try (AgentInvocation inv = tracer.invoke("Diagnose high latency")) {
inv.step(StepType.THOUGHT, "Need to check service metrics");
try (ToolCallScope tool = inv.toolCall("get_service_health")) {
tool.success();
}
inv.complete(true);
}
@AgentMethod annotation (Spring Boot):
@AgentMethod(name = "incident-responder", type = "single", maxSteps = 100)
public IncidentReport diagnose(String incidentId) {
// Automatically wrapped in AgentInvocation — no manual tracer calls
return analyzeAndRespond(incidentId);
}
YAML config (Spring Boot):
agenttel:
agentic:
agents:
incident-responder:
type: single
max-steps: 100
loop-threshold: 5
Quick Start
AgentTel supports multiple integration paths — pick what fits your stack:
| Path | Best For | Effort |
|---|---|---|
| Spring Boot Starter | Spring Boot applications | Add dependency + YAML config |
| Go SDK | Go services (net/http, Gin, gRPC) | go get + YAML config |
| Node.js SDK | Express / Fastify services | npm install + YAML config |
| Python SDK | FastAPI / Python services | pip install + YAML config |
| JavaAgent Extension | Any JVM app (no code changes) | JVM flag + YAML config |
| Web SDK | Browser/SPA applications | npm install + init call |
| Instrument Agent | IDE-assisted setup | Run MCP server in IDE |
Backend: Spring Boot
1. Add Dependencies
Maven:
<dependencies>
<!-- Core: span enrichment, baselines, anomaly detection, SLO tracking -->
<dependency>
<groupId>dev.agenttel</groupId>
<artifactId>agenttel-spring-boot-starter</artifactId>
<version>0.4.0-alpha</version>
</dependency>
<!-- Optional: GenAI instrumentation -->
<dependency>
<groupId>dev.agenttel</groupId>
<artifactId>agenttel-genai</artifactId>
<version>0.4.0-alpha</version>
</dependency>
<!-- Optional: Agent interface layer (MCP server, incident context, remediation) -->
<dependency>
<groupId>dev.agenttel</groupId>
<artifactId>agenttel-agent</artifactId>
<version>0.4.0-alpha</version>
</dependency>
</dependencies>
Gradle:
// build.gradle.kts
dependencies {
// Core: span enrichment, baselines, anomaly detection, SLO tracking
implementation("dev.agenttel:agenttel-spring-boot-starter:0.4.0-alpha")
// Optional: GenAI instrumentation
implementation("dev.agenttel:agenttel-genai:0.4.0-alpha")
// Optional: Agent interface layer (MCP server, incident context, remediation)
implementation("dev.agenttel:agenttel-agent:0.4.0-alpha")
}
2. Configure Your Service
All enrichment is driven by YAML configuration -- no code changes needed:
# application.yml
agenttel:
# Topology: set once on the OTel Resource, associated with all telemetry
topology:
team: payments-platform
tier: critical
domain: commerce
on-call-channel: "#payments-oncall"
dependencies:
- name: postgres
type: database
criticality: required
timeout-ms: 5000
circuit-breaker: true
- name: stripe-api
type: rest_api
criticality: required
fallback: "Return cached pricing"
# Reusable operational profiles — reduce repetition across operations
profiles:
critical-write:
retryable: false
escalation-level: page_oncall
safe-to-restart: false
read-only:
retryable: true
idempotent: true
escalation-level: notify_team
# Per-operation baselines and decision metadata
# Use bracket notation [key] for operation names with special characters
operations:
"[POST /api/payments]":
profile: critical-write
expected-latency-p50: "45ms"
expected-latency-p99: "200ms"
expected-error-rate: 0.001
retryable: true # overrides profile default
idempotent: true
runbook-url: "https://wiki/runbooks/process-payment"
"[GET /api/payments/{id}]":
profile: read-only
expected-latency-p50: "15ms"
expected-latency-p99: "80ms"
baselines:
rolling-window-size: 1000
rolling-min-samples: 10
anomaly-detection:
z-score-threshold: 3.0
3. Optional: Annotate for IDE Support
Annotations are optional -- YAML config above is sufficient. Use @AgentOperation when you want IDE autocomplete and compile-time validation. Reference profiles to avoid repeating values:
@AgentOperation(profile = "critical-write")
@PostMapping("/api/payments")
public ResponseEntity<PaymentResult> processPayment(@RequestBody PaymentRequest req) {
// Your business logic — spans are enriched automatically
}
When both YAML config and annotations define the same operation, YAML config takes priority. Per-operation values override profile defaults.
4. Start the MCP Server (Optional)
// Expose telemetry to AI agents via MCP
McpServer mcp = new AgentTelMcpServerBuilder()
.port(8081)
.contextProvider(agentContextProvider)
.remediationExecutor(remediationExecutor)
.build();
mcp.start();
AI agents can now call tools like get_service_health, get_incident_context, list_remediation_actions, and execute_remediation over JSON-RPC.
5. What You Get
Resource attributes (set once per service, associated with all telemetry):
agenttel.topology.team = "payments-platform"
agenttel.topology.tier = "critical"
agenttel.topology.domain = "commerce"
agenttel.topology.on_call_channel = "#payments-oncall"
agenttel.topology.dependencies = [{"name":"postgres","type":"database",...}]
Span attributes (per operation, only on operations with registered metadata):
agenttel.baseline.latency_p50_ms = 45.0
agenttel.baseline.latency_p99_ms = 200.0
agenttel.baseline.error_rate = 0.001
agenttel.baseline.source = "static"
agenttel.decision.retryable = true
agenttel.decision.runbook_url = "https://wiki/runbooks/process-payment"
agenttel.decision.escalation_level = "page_oncall"
agenttel.anomaly.detected = false
agenttel.slo.budget_remaining = 0.85
When an incident occurs, agents get structured context via MCP:
=== INCIDENT inc-a3f2b1c4 ===
SEVERITY: HIGH
SUMMARY: POST /api/payments experiencing elevated error rate (5.2%)
## WHAT IS HAPPENING
Error Rate: 5.2% (baseline: 0.1%)
Latency P50: 312ms (baseline: 45ms)
Patterns: ERROR_RATE_SPIKE
## WHAT CHANGED
Last Deploy: v2.1.0 at 2025-01-15T14:30:00Z
## WHAT IS AFFECTED
Scope: operation_specific
User-Facing: YES
Affected Deps: stripe-api
## SUGGESTED ACTIONS
- [HIGH] rollback_deployment: Rollback to previous version (NEEDS APPROVAL)
- [MEDIUM] enable_circuit_breakers: Circuit break stripe-api
Backend: Python (FastAPI)
1. Install
pip install agenttel[fastapi]
# Optional extras
pip install agenttel[openai] # OpenAI instrumentation
pip install agenttel[anthropic] # Anthropic instrumentation
pip install agenttel[langchain] # LangChain instrumentation
pip install agenttel[all] # Everything
2. Configure
# agenttel.yml
agenttel:
topology:
service-name: payment-service
team: payments-platform
tier: critical
domain: commerce
on-call-channel: "#payments-oncall"
operations:
"POST /api/payments":
expected-latency-p50: 45ms
expected-latency-p99: 200ms
retryable: true
runbook-url: "https://wiki/runbooks/process-payment"
slo:
availability:
target: 0.999
type: availability
3. Instrument
from fastapi import FastAPI
from agenttel.fastapi import instrument_fastapi
app = FastAPI()
instrument_fastapi(app) # One-line integration
instrument_fastapi() attaches the AgentTel span processor to your existing OpenTelemetry TracerProvider (or creates one if none is set), instruments the app with opentelemetry-instrumentation-fastapi, and enriches each HTTP server span with topology, baselines and decision attributes for its METHOD /route — identical attributes to the JVM SDK.
Backend: Go
1. Install
go get go.agenttel.dev/agenttel-go@latest
2. Configure
# agenttel.yml — same format as JVM/Python SDKs
agenttel:
topology:
service-name: payment-service
team: payments-platform
tier: critical
operations:
"POST /api/payments":
expected-latency-p50: 45ms
expected-latency-p99: 200ms
retryable: true
3. Instrument
import (
"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
agenttel "go.agenttel.dev/agenttel-go"
agmw "go.agenttel.dev/agenttel-go/middleware/http"
)
engine, err := agenttel.New().WithConfigFile("agenttel.yml").Build()
if err != nil {
log.Fatal(err)
}
tp := sdktrace.NewTracerProvider(
sdktrace.WithResource(engine.Resource()), // topology on the resource
sdktrace.WithSpanProcessor(engine.SpanProcessor()),
sdktrace.WithBatcher(exporter),
)
otel.SetTracerProvider(tp)
// otelhttp creates the server span; AgentTel enriches it for the matched "METHOD /route"
handler := otelhttp.NewHandler(agmw.Middleware(agmw.WithEngine(engine))(mux), "server")
Requires go.opentelemetry.io/otel/sdk v1.39.0+.
Also supports Gin (middleware/gin) and gRPC (middleware/grpc) out of the box. See Go Quickstart for details.
Backend: Node.js (Express / Fastify)
1. Install
npm install @agenttel/node @opentelemetry/api @opentelemetry/sdk-trace-node @opentelemetry/instrumentation-http
2. Configure
# agenttel.yml — same format as all other SDKs
agenttel:
topology:
service-name: payment-service
team: payments-platform
tier: critical
operations:
"POST /api/payments":
expected-latency-p50: 45ms
expected-latency-p99: 200ms
retryable: true
3. Instrument
import { AgentTelEngine, expressMiddleware } from '@agenttel/node';
const engine = AgentTelEngine.fromConfigFile('agenttel.yml');
// Register the processor with your tracer provider (alongside your exporter)
const provider = new NodeTracerProvider({
resource: new Resource(engine.resourceAttributes()),
spanProcessors: [engine.spanProcessor, new BatchSpanProcessor(exporter)],
});
provider.register();
registerInstrumentations({ instrumentations: [new HttpInstrumentation(), new ExpressInstrumentation()] });
app.use(expressMiddleware({ engine })); // topology, baselines and decisions on the server span
Works under plain node as ESM (import) or CommonJS (require), Node.js 18+.
Also supports Fastify (fastifyPlugin). See Node.js Quickstart for details.
Frontend: Browser SDK
npm install @agenttel/web
import { AgentTelWeb } from '@agenttel/web';
AgentTelWeb.init({
appName: 'checkout-web',
appVersion: '1.0.0',
environment: 'production',
collectorEndpoint: '/otlp',
routes: {
'/checkout/:step': {
businessCriticality: 'revenue',
baseline: { pageLoadP50Ms: 800, apiCallP50Ms: 300 },
decision: { escalationLevel: 'page_oncall', runbookUrl: 'https://wiki/runbooks/checkout' },
},
},
journeys: {
checkout: {
steps: ['/products', '/cart', '/checkout/shipping', '/checkout/payment', '/confirmation'],
baseline: { completionRate: 0.65, avgDurationS: 300 },
},
},
anomalyDetection: {
rageClickThreshold: 3,
apiFailureCascadeThreshold: 3,
errorLoopThreshold: 5,
},
});
The SDK automatically instruments page loads, SPA navigation, API calls, clicks, and errors — with cross-stack correlation via W3C Trace Context headers.
IDE: Instrument Agent
Run the instrument agent as an MCP server in your IDE (Cursor, VS Code, etc.):
pip install agenttel-instrument
agenttel-instrument --config instrument.yml
Then ask your IDE agent: "Analyze my codebase and generate AgentTel configuration" — it will scan your endpoints, detect dependencies, and generate a complete agenttel.yml.
AgentTel MCP 질문
AgentTel MCP는 어떤 도구를 제공하나요?
2개 도구를 제공합니다. 예: agenttel, agenttel-instrument.
AgentTel은 표준 관측성(Observability)에 무엇을 추가하나요?
표준 관측성이 '무엇이 일어났는가?'에 답한다면, AgentTel은 행동 베이스라인, 토폴로지 인식, 의사결정 메타데이터와 같이 AI agent가 행동하는 데 필요한 컨텍스트를 추가합니다.
어떤 프로그래밍 언어를 지원하나요?
SDK는 Java, Kotlin, Scala, Go, Node.js, TypeScript, Python(FastAPI, Django, Flask 포함) 및 브라우저 프론트엔드를 지원합니다.