Now in public beta

Your AI agent is running in production. Do you know if it's answering well?

Most observability tools show you what happened. Sentygent tells you if it was good. An independent sentinel agent evaluates every conversation automatically — relevance, helpfulness, safety — with zero configuration.

Start for Free See how it works ↓

⚡ 5-line integration

🔍 5 quality dimensions

💳 No credit card required

Senty, the Sentygent sentinel agent mascot

agent.ts

monitored by Senty

import { SentygentClient, instrumentAnthropic } from '@sentygent/sdk';

const sentygent = new SentygentClient({
  apiKey: process.env.SENTYGENT_API_KEY,
  agent: 'my-agent',
});
const anthropic = instrumentAnthropic(new Anthropic(), sentygent);

// Wrap calls in a trace — evaluated automatically
await sentygent.trace(`chat-${Date.now()}`, async (span) => {
  span.captureLifecycle('message_received', { content: userMessage });
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    messages: [{ role: 'user', content: userMessage }],
  });
  span.captureLifecycle('message_sent', { content: response.content[0].text });
});

You have observability. You don't have quality.

89%

of teams with AI agents in production have observability

— they see the traces

52%

evaluate response quality

— only half know if their agent is answering well

Your team sees every LLM call. You know the latency, the tokens, the cost. But can you answer: "Is my agent actually helping users?"

Quality problems are the #1 production barrier — reported by 32% of teams. They're discovered when users complain, not proactively.

The production quality gap

User asks

Agent responds

User complains

You find out

This gap. Sentygent fills it.

Real-time quality evaluation between response and complaint.

From zero to quality monitoring in 5 minutes

Step 01 Install

terminal

$ npm install @sentygent/sdk

One package. Zero peer dependencies you don't already have.

Step 02 Instrument — 5 lines

agent.ts

import { SentygentClient, instrumentAnthropic } from '@sentygent/sdk';
const sentygent = new SentygentClient({ apiKey: process.env.SENTYGENT_API_KEY, agent: 'my-agent' });
const anthropic = instrumentAnthropic(new Anthropic(), sentygent);
// Your existing code unchanged ✓

Wrap your existing client. No refactoring required.

Step 03 Monitor

Open your dashboard. Every conversation has a quality score across 5 dimensions. Set alerts. Ship with confidence.

RelevanceHelpfulnessCompletenessCoherenceSafety

The Sentinel Agent

An independent LLM-as-judge that evaluates every conversation

Your AI Agent

User message

[Your Agent LLM]

Response

Sent to Sentygent API (async, zero latency impact)

Sentinel Agent (LLM-as-judge)

Evaluates across 5 dimensions:

Relevance — aligned with the question?

Helpfulness — useful and actionable?

Completeness — no important aspects omitted?

Coherence — clear and logical structure?

Safety — no problematic content?

Quality Score 8.7/10

Zero configuration

No datasets, no rubrics, no manual setup. Works out of the box with sensible defaults for any conversational AI.

Fully async

Evaluation happens asynchronously. Zero latency impact on your agent. Your users never wait for the sentinel.

Safety auto-alert

If safety score drops below 30, you're alerted immediately. Automatically. No rule configuration needed.

Full trace visibility with quality context

See every step of every conversation with quality scores attached. Not just what happened — how good it was.

sentygent

Live conv_a8f2

Quality Score

8.7 / 10 ↑ 0.3 from last hour

Conversation ID: conv_a8f2

Overall 87%

Relevance

9.2

Helpfulness

8.1

Completeness

8.8

Coherence

9.0

Safety

10.0

Trace Timeline

23 steps

USER "How do I configure rate limiting in..." 0ms

LLM claude-opus-4-6 ↓ 1.2k tokens $0.018 142ms

TOOL search_docs("rate limiting") 98ms

RAG 3 chunks retrieved relevance: 0.94 45ms

LLM claude-opus-4-6 ↓ 892 tokens $0.012 118ms

ASSISTANT Response generated 0ms

Total cost: $0.031 Total latency: 403ms LLM calls: 6

Everything you need to monitor AI quality in production

Not just tracing. Not just metrics. Actual quality evaluation that tells you if your agent is doing its job.

Automatic Quality Scoring

Every conversation evaluated across 5 dimensions. Zero config, zero datasets.

Trace Timeline

Visual step-by-step: LLM calls, tool calls, RAG retrievals, errors. Expandable per step.

Multi-agent Tracing

Orchestrator + sub-agents with per-agent cost breakdown. Full hierarchy visibility.

Quality Alerts

Webhook when average quality drops below threshold in configurable time window.

Safety Auto-alert

Instant alert when safety < 30. No rule needed. Automatic, always on.

Cost Transparency

Cost per agent, per conversation, per step. Know exactly what you're spending.

Dimensional Tags

Segment metrics by any dimension: courseId, intent, model version, step.

RAG/Retrieval Events

Native event type for search steps with relevance scores. First-class RAG support.

Works with every major LLM provider

Auto-instrumentation for supported clients. Typed helpers for everything else.

Anthropic

Amazon Bedrock

OpenAI

Cohere

Mistral

Groq

Ollama

Provider	Auto-instrumentation Wrap client, zero code changes	Typed helpers Typed event tracking
Anthropic	✓	—
Amazon Bedrock	✓	—
OpenAI	—	✓
Cohere	—	✓
Mistral	—	✓
Groq	—	✓
Ollama	—	✓

Auto-instrumentation: wrap your client, zero code changes to existing logic

Typed helpers: typed event tracking for any provider with full TypeScript support

Built for production quality. Not just tracing.

Existing tools tell you what happened. Sentygent tells you if it was good.

Capability	Langfuse	LangSmith	Helicone	Braintrust	Sentygent You
Auto quality scoring	Manual setup	Manual setup	✗	Requires config	✓ Zero-config
Quality degradation alerts	✗	✗	✗	✗	✓
Safety auto-alert	✗	✗	✗	✗	✓
Multi-agent cost breakdown	✗	Partial	✗	✗	✓
RAG as native event	✗	✗	✗	✗	✓
Integration time	15-30 min	15-30 min	2 min (proxy)	30-60 min	5 min
Starting price	Free	Free	Free	Free	Free

Based on public documentation as of Q1 2025. Some features may vary.

Integration in 5 lines. Seriously.

No major refactoring. No new abstractions to learn. Just wrap and monitor.

agent.ts

import Anthropic from '@anthropic-ai/sdk';
import { SentygentClient, instrumentAnthropic } from '@sentygent/sdk';

const sentygent = new SentygentClient({
  apiKey: process.env.SENTYGENT_API_KEY,
  agent: 'my-chatbot',
});
const anthropic = instrumentAnthropic(new Anthropic(), sentygent);

await sentygent.trace(`chat-${Date.now()}`, async (span) => {
  span.captureLifecycle('message_received', { content: userMessage });
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    messages: [{ role: 'user', content: userMessage }],
  });
  span.captureLifecycle('message_sent', { content: response.content[0].text });
});
// Quality evaluation happens automatically in background

agent.ts

import { BedrockRuntimeClient, ConverseCommand } from '@aws-sdk/client-bedrock-runtime';
import { SentygentClient, instrumentBedrock } from '@sentygent/sdk';

const sentygent = new SentygentClient({
  apiKey: process.env.SENTYGENT_API_KEY,
  agent: 'my-bedrock-agent',
});
const bedrock = instrumentBedrock(
  new BedrockRuntimeClient({ region: 'eu-west-1' }), sentygent);

await sentygent.request(`session-${Date.now()}`, async (span) => {
  span.captureLifecycle('message_received', { content: userQuestion });
  const response = await bedrock.send(new ConverseCommand({
    modelId: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
    messages: [{ role: 'user', content: [{ text: userQuestion }] }],
  }));
  span.captureLifecycle('message_sent', { content: response.output?.message?.content?.[0]?.text });
});

agent.ts

import OpenAI from 'openai';
import { SentygentClient } from '@sentygent/sdk';

const sentygent = new SentygentClient({
  apiKey: process.env.SENTYGENT_API_KEY,
  agent: 'my-openai-agent',
});
const openai = new OpenAI();

// OpenAI: use span.captureLLM() — no auto-instrumentation
await sentygent.trace(`chat-${Date.now()}`, async (span) => {
  await span.captureLLM({
    provider: 'openai',
    model: 'gpt-4o',
    execute: () => openai.chat.completions.create({
      model: 'gpt-4o',
      messages: [{ role: 'user', content: userMessage }],
    }),
    extractUsage: (r) => r.usage,
  });
});

agent.ts

import { SentygentClient } from '@sentygent/sdk';

const sentygent = new SentygentClient({ apiKey: process.env.SENTYGENT_API_KEY, agent: 'orchestrator' });

await sentygent.trace(`multi-agent-${Date.now()}`, async (span) => {
  // Research sub-agent — separate slug in dashboard
  const researchSpan = span.child('research', { agent: 'research-agent' });
  const research = await researchSpan.captureLLM({
    provider: 'anthropic', model: 'claude-sonnet-4-20250514',
    execute: () => callLLM('Summarize AI safety research findings'),
    extractUsage: (r) => r.usage,
  });

  // Writer sub-agent — per-agent cost in dashboard
  const writerSpan = span.child('write', { agent: 'writer-agent' });
  await writerSpan.captureLLM({
    provider: 'anthropic', model: 'claude-sonnet-4-20250514',
    execute: () => callLLM('Write polished summary from research notes'),
    extractUsage: (r) => r.usage,
  });
});
await sentygent.shutdown();