You've deployed AI agents into production.
The quality layer is missing.

AgentIQ evaluates every interaction at every step, in real time — not a sample, not after the fact — and tells you exactly what broke, where, and why.

Enterprise AI agents run complex multi-step workflows. Unlike traditional software, agents think and act differently in every interaction — standard quality checks aren't built for that. Eval and observability platforms exist, but they use sampled data and after-the-fact analysis. They miss failures mid-workflow, including one-off failures that could be catastrophic.

• Evaluates every interaction at every step, the moment it happens
• Gives every interaction a quality score calibrated to your industry
• Surfaces one-off catastrophic failures immediately in the Failure Feed
• Groups repeating failures into named patterns with plain English root cause

From pip install to your first scored interaction in under two minutes.

$ pip install agentiq

import agentiq

agentiq.init(
  api_key="sk-aiq-...",
  industry="retail",  # healthcare | retail | coding | marketing
)

@agentiq.watch
def support_agent(user_input):
    ...  # nothing else changes

$ python agent.py

✓ AgentIQ connected
  Evaluating every step in real time
  Dashboard: https://agentiq.dev/a/abc123

Interaction 1 · Score 91/100 · PASSED
Interaction 2 · Score 34/100 · FAILED → tool_failure at step 3

The trace call never blocks and never raises. If AgentIQ's API is unreachable, your agent keeps running. Failed sends are logged locally and retried automatically.

Every interaction gets a quality score from 0 to 100, computed from four dimensions evaluated by an LLM judge on every step.

An interaction passes when overall_score ≥ 0.7. Configurable per agent from the dashboard.

A healthcare agent and a marketing agent shouldn't be graded the same way. AgentIQ ships with quality weightings tuned per industry, applied automatically when you set industry in init().

agentiq.configure(
  weight_accuracy=0.40,
  weight_goal_alignment=0.30,
  weight_decision_quality=0.15,
  weight_completeness=0.15,
  pass_threshold=0.75,
)

Every failed interaction is classified into one of seven failure types. This taxonomy is published research — the same definitions used across our research papers.

Three views. Each answers one question: is my agent healthy, what's failing right now, and exactly what happened in this one interaction.

The landing view. Quality score trend over 7 days, today's pass rate, active failure count, and top 3 failure types ranked by frequency. If no failures in 24h: "No failures detected. Your agent is healthy."

Every failure the moment it happens — not on a batch schedule. One-off failures shown individually, flagged in red. Repeating patterns grouped automatically once 5+ failures share the same type and step, with a one-sentence root cause in the pattern card.

Full step-by-step trace for one interaction. Per-step quality score, green or red. The failing step highlighted, not buried. Failure reason in one plain English sentence — not a JSON dump, not a stack trace.

Authenticates AgentIQ and sets defaults for the current process. Call once at startup.

agentiq.init(
  api_key: str,
  industry: str = "default",
  agent_id: str | None = None,
) -> None

A decorator that instruments any agent function. Internally calls agentiq.trace() after every step the wrapped function emits.

@agentiq.watch
def your_agent(user_input: str) -> str:
    ...

Works with any Python callable — LangChain chains, CrewAI agents, AutoGen agents, or a plain function. No framework-specific integration required.

Manually log one step of an interaction. Use when your agent can't be wrapped with @watch.

agentiq.trace(
  session_id: str,
  step_number: int,
  step_name: str,
  input: str,
  output: str,
  tool_calls: list | None = None,
  metadata: dict | None = None,
  session_ended: bool = False,
) -> None

Four tables. Everything AgentIQ stores, nothing more.

Written by the SDK on every trace call. The raw record of one step.

id              UUID primary key
agent_id        str
session_id      str
step_number     int
step_name       str
input           str
output          str
tool_calls      jsonb
latency_ms      int
session_ended   bool
timestamp       timestamptz
metadata        jsonb

Written by the judge. One row per step evaluated.

id                UUID primary key
log_id            UUID  -- FK to AgentLog
session_id        str
agent_id          str
accuracy          float
goal_alignment    float
decision_quality  float
completeness      float
overall_score     float  -- weighted average, 0.0–1.0
passed            bool   -- overall_score >= 0.7
failure_type      str    -- null if passed
failure_step      int
failure_reason    str    -- one plain English sentence
evaluated_at      timestamptz

Written hourly. Aggregated, named failure patterns.

id                   UUID primary key
agent_id             str
pattern_type         str   -- intent | workflow_step | tool_call
pattern_value        str
failure_count        int
failure_rate         float
pct_of_all_failures  float
root_cause           str
is_worsening         bool
first_seen / last_seen  timestamptz

Your per-agent quality configuration.

agent_id              str primary key
industry              str
weight_accuracy       float
weight_goal_alignment float
weight_decision       float
weight_completeness   float
pass_threshold        float  -- default 0.7