agentx-python 0.8.14__py3-none-any.whl → 0.8.16__py3-none-any.whl

agentx/evaluations/client.py

@@ -314,10 +314,15 @@ class EvaluationsClient:
         scorer_id: Optional[str] = None,
         evaluation_settings_id: Optional[str] = None,
         split: Optional[str] = None,
+        additional_scorer_ids: Optional[List[str]] = None,
+        scorer_group_id: Optional[str] = None,
     ) -> EvaluationRun:
         """``scorer_id`` names the LLM Judge Scorer grading this run (its id doubles as the
         wire's ``evaluationSettingsId``). ``evaluation_settings_id`` is the pre-consolidation
-        alias and keeps working. ``split`` records the named case subset this run covers."""
+        alias and keeps working. ``split`` records the named case subset this run covers.
+        ``additional_scorer_ids`` (self-host): extra judge scorers that each pass their own
+        verdict on every result from the same single agent execution - verdicts land in each
+        result row's ``judgeScorerResults`` and the run's ``scorerBreakdown``."""
         from agentx.version import VERSION
 
         grader_id = _resolve_scorer_id(scorer_id, evaluation_settings_id)
@@ -335,6 +340,12 @@ class EvaluationsClient:
         }
         if grader_id:
             payload["evaluationSettingsId"] = grader_id
+        if additional_scorer_ids:
+            payload["additionalScorerIds"] = additional_scorer_ids
+        # Scorer group grading (self-host): the group's weighted 0-10 aggregate fills the rating
+        # column and member verdicts land per row. Mutually exclusive with scorer_id (group wins).
+        if scorer_group_id:
+            payload["scorerGroupId"] = scorer_group_id
         if split:
             payload["split"] = split
         data = self._request("POST", "/runs", json=self._with_workspace(payload))
@@ -372,6 +383,7 @@ class EvaluationsClient:
         tolerance: Optional[float] = None,
         record: bool = True,
         caller: Optional[str] = "sdk",
+        scorer: Optional[str] = None,
     ) -> Dict[str, Any]:
         # CI gate (self-host): pass/fail a finalized run against an absolute rating floor and/or
         # the dataset's previous completed run. Recorded into gate history by default (the
@@ -389,6 +401,11 @@ class EvaluationsClient:
             params["record"] = "true"
             if caller:
                 params["caller"] = caller
+        # Multi-judge runs (self-host): gate a named additional scorer (id or name, e.g.
+        # scorer="Safety") instead of the primary - failUnder/noRegression then use that
+        # scorer's own per-result verdicts. Unknown names are a hard 400 from the engine.
+        if scorer:
+            params["scorer"] = scorer
         return self._request("GET", f"/runs/{run_id}/gate", params=params)
 
     def analyze_run(

agentx/evaluations/models.py

@@ -75,6 +75,9 @@ class Dataset(BaseModel):
     rejection_criteria: Optional[str] = Field(default=None, alias="rejectionCriteria")
     evaluation_criteria: Optional[str] = Field(default=None, alias="evaluationCriteria")
     questions: List[DatasetQuestion] = Field(default_factory=list)
+    # Custom code scorers attached to this dataset - [{ id, name, code, enabled }]. Retrievable,
+    # so a fetched dataset round-trips them (import_dataset copies them to the new dataset).
+    code_scorers: Optional[List[Dict[str, Any]]] = Field(default=None, alias="codeScorers")
     status: str = "published"
     version_id: Optional[str] = Field(default=None, alias="versionId")
     # Sovereignty & Portability - models selected to compare on this dataset.
@@ -108,6 +111,8 @@ class EvaluationSettings(BaseModel):
     acceptance_criteria: Optional[str] = Field(default=None, alias="acceptanceCriteria")
     rejection_criteria: Optional[str] = Field(default=None, alias="rejectionCriteria")
     evaluation_criteria: Optional[str] = Field(default=None, alias="evaluationCriteria")
+    # Custom code scorers on this scorer's offline profile - [{ id, name, code, enabled }].
+    code_scorers: Optional[List[Dict[str, Any]]] = Field(default=None, alias="codeScorers")
     # LLM-as-judge overrides. None means "use the server default" (raw prompt template / OpenAI
     # gpt-5.5). See client.evaluations.settings.builder(judge_prompt=..., judge_model=...).
     judge_prompt: Optional[str] = Field(default=None, alias="judgePrompt")
@@ -435,6 +440,8 @@ class RunResultRow(BaseModel):
     bleu_score: Optional[float] = Field(default=None, alias="bleuScore")
     rouge_score: Optional[float] = Field(default=None, alias="rougeScore")
     code_scorer_results: Optional[List[Dict[str, Any]]] = Field(default=None, alias="codeScorerResults")
+    # Verdicts from the run's ADDITIONAL judge scorers: [{scorerId, name, rating, justification}].
+    judge_scorer_results: Optional[List[Dict[str, Any]]] = Field(default=None, alias="judgeScorerResults")
     raw: Dict[str, Any] = Field(default_factory=dict)
 
     class Config:

agentx/evaluations/runner.py

@@ -77,6 +77,9 @@ class GateResult:
         self.baseline_average: Optional[float] = data.get("baselineAverage")
         self.baseline_run_id: Optional[str] = data.get("baselineRunId")
         self.checks: List[Dict[str, Any]] = data.get("checks", [])
+        # Multi-judge runs: {"id", "name"} of the additional scorer being gated when the gate
+        # ran with scorer=..., None when gating the primary.
+        self.gated_scorer: Optional[Dict[str, Any]] = data.get("gatedScorer")
 
     @property
     def exit_code(self) -> int:
@@ -354,13 +357,16 @@ class EvaluationRunContext:
         no_regression: bool = False,
         tolerance: Optional[float] = None,
         caller: str = "sdk",
+        scorer: Optional[str] = None,
     ) -> "GateResult":
         """CI gate (self-host): pass/fail this finalized run so a CI job can block a merge.
 
         ``fail_under`` fails the gate when the run's average rating is below the floor;
         ``no_regression=True`` fails it when the average dropped more than ``tolerance``
         (default 0.5, judge scores are noisy) below the dataset's previous completed run.
-        At least one check is required. Prints a CI-log-friendly verdict and returns a
+        At least one check is required. On a multi-judge run, ``scorer`` (an additional
+        scorer's id or name, e.g. ``scorer="Safety"``) gates that scorer's own average
+        instead of the primary's - "fail if Safety is low even when the average looks fine". Prints a CI-log-friendly verdict and returns a
         :class:`GateResult` - the caller decides the exit code::
 
             report = client.evaluations.run(...).execute(my_agent).finalize()
@@ -374,6 +380,7 @@ class EvaluationRunContext:
             no_regression=no_regression,
             tolerance=tolerance,
             caller=caller,
+            scorer=scorer,
         )
         result = GateResult(data)
         _say()
@@ -589,6 +596,7 @@ class EvaluationsRunner:
         tolerance: Optional[float] = None,
         record: bool = True,
         caller: Optional[str] = "sdk",
+        scorer: Optional[str] = None,
     ) -> GateResult:
         """CI-gate any finalized run by id - the standalone form of
         ``EvaluationRunContext.gate()``, for gating a run created elsewhere or
@@ -603,6 +611,7 @@ class EvaluationsRunner:
                 tolerance=tolerance,
                 record=record,
                 caller=caller,
+                scorer=scorer,
             )
         )
 
@@ -613,6 +622,8 @@ class EvaluationsRunner:
         scorer_id: Optional[str] = None,
         evaluation_settings_id: Optional[str] = None,
         split: Optional[str] = None,
+        additional_scorer_ids: Optional[List[str]] = None,
+        scorer_group_id: Optional[str] = None,
     ) -> EvaluationRunContext:
         """Start a run of ``dataset_id`` against ``subject``. Pass ``scorer_id`` (an LLM Judge
         Scorer's id, e.g. from ``client.monitor.judge_scorers``) to grade with a specific
@@ -632,7 +643,14 @@ class EvaluationsRunner:
         evaluation_settings = (
             self._client.get_evaluation_settings(grader_id) if grader_id else None
         )
-        run = self._client.init_run(dataset_id, subject, scorer_id=grader_id, split=split)
+        run = self._client.init_run(
+            dataset_id,
+            subject,
+            scorer_id=grader_id,
+            split=split,
+            additional_scorer_ids=additional_scorer_ids,
+            scorer_group_id=scorer_group_id,
+        )
         case_count = (
             sum(1 for q in dataset.questions if split in (q.main_question.splits or []))
             if split

agentx/monitor/client.py

@@ -67,6 +67,22 @@ class CalibrationSummary(dict):
     def review_label_count(self) -> int:
         return int(self.get("reviewLabelCount") or 0)
 
+    @property
+    def alpha(self):
+        """Chance-corrected agreement (Krippendorff's alpha over the binary verdict pair) -
+        the raw ``agreement_rate`` corrected for what a weighted coin would score on this
+        label mix. ``None`` below the server's sample floor (``alphaMinItems`` labeled pairs)
+        or when every label is identical: withheld, never fabricated. 1 = perfect, 0 = no
+        better than chance, negative = systematically opposed."""
+        return self.get("alpha")
+
+    @property
+    def alpha_band(self):
+        """Human-readable band for ``alpha`` (poor/slight/fair/moderate/substantial/
+        near-perfect), computed server-side so every surface reads the same alpha the
+        same way."""
+        return self.get("alphaBand")
+
 
 class MonitorClient:
     """Low-level HTTP client for the Monitor API (``/monitor``). Accessed via
@@ -131,6 +147,16 @@ class MonitorClient:
         # surface that matches the product; evaluations.settings and online_evaluators below
         # remain as its profile-level views.
         self.judge_scorers = JudgeScorersClient(api_key=api_key, base_url=self._api_root())
+        from agentx.monitor.scorer_groups import ScorerGroupsClient
+
+        # Scorer groups: mixed-kind scorers composed into one 0-10 score (weights + must-pass
+        # gates) - a group grades dataset runs (scorer_group_id) and, when online, live traffic.
+        self.scorer_groups = ScorerGroupsClient(api_key=api_key, base_url=self._api_root())
+        from agentx.monitor.improvement_groups import ImprovementGroupsClient
+
+        # Auto-improve: confirmed production failures -> improvement report -> code fix (via
+        # the AgentX-Eval-Skill auto-improve skill). Self-host only.
+        self.improvement_groups = ImprovementGroupsClient(api_key=api_key, base_url=self._api_root())
         self.profile = MonitorProfileClient(self)
         # Legacy view of an LLM Judge Scorer's online profile - constructed lazily so its
         # DeprecationWarning fires on first USE, not for every client that never touches it.
@@ -317,8 +343,12 @@ class MonitorClient:
         AgentX's own verdicts agreed with real-world ground truth reported later (ops outcomes
         via ``client.outcomes``, end-user downvotes, and human review labels). Returns the
         dashboard's Judge Calibration numbers with these exact keys: ``comparedCount``,
-        ``agreementRate``, ``falsePositiveRate``, ``falseNegativeRate`` (plus
-        ``reportedCount``/``reviewLabelCount``/``noVerdictCount``). Per-scorer calibration
+        ``agreementRate``, ``falsePositiveRate``, ``falseNegativeRate``, ``alpha``,
+        ``alphaBand``, ``alphaMinItems`` (plus
+        ``reportedCount``/``reviewLabelCount``/``noVerdictCount``). ``agreementRate`` is raw
+        agreement and inflates under class imbalance; ``alpha`` is the chance-corrected
+        version (Krippendorff's alpha - null until ``alphaMinItems`` labeled pairs exist).
+        Per-scorer calibration
         lives on ``client.monitor.judge_scorers.calibration(scorer_id)``."""
         return CalibrationSummary(
             self._request(

agentx/monitor/improvement_groups.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from agentx.util import api_base, get_headers
+
+
+class AgentXImprovementGroupsError(Exception):
+    pass
+
+
+class ImprovementGroupsClient:
+    """Surfaced as ``client.monitor.improvement_groups``: the auto-improve loop's accumulator.
+
+    Batch lifecycle: one COLLECTING group at a time. Every Confirm verdict in signal review
+    automatically lands the confirmed failure there - accumulation is free, declining is
+    choosing Ignore. ``generate_report`` SPENDS the batch: one LLM pass clusters the confirmed
+    failures into issues with recommendations, the group is sealed onto that report (keeping
+    exactly its source cases), and the pending accumulator is thereby cleared - the next
+    Confirm starts a fresh batch, and the next generate makes a new report from it. The report's id is the
+    hand-off: paste it into the AgentX-Eval-Skill ``auto-improve`` skill, which fetches the
+    report (``get_report``) and triages the fixes against your agent's actual source code.
+
+    Evidence here is exclusively ONLINE - production verdicts a human confirmed - never
+    offline dataset runs. Self-host only.
+    """
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
+        self._api_key = api_key
+        self._base_url = (base_url or api_base()).rstrip("/")
+
+    def _request(self, method: str, path: str, json: Any = None, timeout: int = 120) -> Any:
+        resp = requests.request(
+            method,
+            f"{self._base_url}/agent-monitoring{path}",
+            headers={**get_headers(self._api_key), "Content-Type": "application/json"},
+            json=json,
+            timeout=timeout,
+        )
+        if resp.status_code >= 400:
+            try:
+                detail = resp.json().get("error", resp.reason)
+            except ValueError:
+                detail = resp.reason
+            raise AgentXImprovementGroupsError(f"Improvement group request failed ({resp.status_code}): {detail}")
+        return resp.json() if resp.text else {}
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self._request("GET", "/improvement-groups").get("improvementGroups", [])
+
+    def get(self, group_id: str) -> Dict[str, Any]:
+        """The group with its members - each a confirmed failure's evidence snapshot."""
+        return self._request("GET", f"/improvement-groups/{group_id}")["improvementGroup"]
+
+    def remove_member(self, group_id: str, member_id: str) -> None:
+        """Prune a member before spending the group (a confirm that turned out uninteresting)."""
+        self._request("DELETE", f"/improvement-groups/{group_id}/members/{member_id}")
+
+    def generate_report(self, group_id: str, model: Optional[str] = None) -> Dict[str, Any]:
+        """Spend the group: one real LLM call clustering the confirmed failures into issues
+        with recommendations. Returns the report; its ``_id`` is what the auto-improve skill
+        takes. Explicit and billed - never called implicitly."""
+        payload: Dict[str, Any] = {}
+        if model is not None:
+            payload["model"] = model
+        return self._request("POST", f"/improvement-groups/{group_id}/report", json=payload, timeout=300)["report"]
+
+    def list_reports(self) -> List[Dict[str, Any]]:
+        return self._request("GET", "/improvement-reports").get("improvementReports", [])
+
+    def get_report(self, report_id: str) -> Dict[str, Any]:
+        """Fetch a report by the id the dashboard (or generate_report) handed out - the exact
+        call the auto-improve skill makes."""
+        return self._request("GET", f"/improvement-reports/{report_id}")["report"]

agentx/monitor/judge_scorers.py

@@ -36,6 +36,11 @@ class JudgeScorer(dict):
     def offline(self) -> Dict[str, Any]:
         return self.get("offline", {})
 
+    @property
+    def code_scorers(self) -> List[Dict[str, Any]]:
+        """Custom code scorers on the offline profile - [{ id, name, code, enabled }]."""
+        return list(self.offline.get("codeScorers") or [])
+
     @property
     def online(self) -> Optional[Dict[str, Any]]:
         return self.get("online")
@@ -258,11 +263,19 @@ class JudgeScorersClient:
 
     def calibration(self, scorer_id: str, window: str = "7d") -> dict:
         """How this scorer's verdicts compare against recorded ground truth (triage
-        corrections, outcomes, end-user votes) over the window."""
+        corrections, outcomes, end-user votes) over the window. Beyond the raw
+        ``agreementRate``, the response carries ``alpha``/``alphaBand`` (chance-corrected
+        agreement - Krippendorff's alpha, null until ``alphaMinItems`` labeled pairs exist)
+        and ``ratingMae`` (mean absolute error against human re-scores, over the
+        ``withCorrectedScore`` pairs that carry a number). ``window`` accepts "24h", "7d",
+        "30d", or "rubric" - only verdicts produced by the CURRENT rubric (since its criteria
+        were last edited, clamped to 30 days), which is what the dashboard's Tune Judge flow
+        uses by default; the response's ``window``/``since`` echo the boundary applied."""
         return self._request("GET", f"/online-evaluators/{self._profile_id(scorer_id)}/calibration?window={window}")
 
     def tune(self, scorer_id: str, window: str = "7d") -> dict:
-        """Propose a rewrite of the rubric from calibration disagreements (LLM call, slow)."""
+        """Propose a rewrite of the rubric from calibration disagreements (LLM call, slow).
+        ``window`` accepts the same values as :meth:`calibration`, including "rubric"."""
         data = self._request(
             "POST", f"/online-evaluators/{self._profile_id(scorer_id)}/tune", json={"window": window}, timeout=300
         )

agentx/monitor/scorer_groups.py

@@ -0,0 +1,88 @@
+"""Scorer groups (self-host): scorers of any kind - LLM judges, patterns, custom code/external
+scorers - composed into ONE 0-10 score via per-member weights and optional must-pass gates.
+Members are references: ``{"kind": "judge" | "pattern" | "custom", "refId": ..., "weight": ...,
+"gate": ...}``. Grade a dataset run with a group by passing its id as ``scorer_group_id`` to
+``client.evaluations.run(...)``; give it an ``online`` profile to score sampled live traffic and
+raise Signals below the alert threshold."""
+
+from typing import Any, Dict, List, Optional
+
+import requests
+
+
+class AgentXScorerGroupsError(Exception):
+    pass
+
+
+class ScorerGroup(dict):
+    """Wire object (dict subclass so unknown fields round-trip)."""
+
+    @property
+    def id(self) -> str:
+        return self["_id"]
+
+    @property
+    def name(self) -> str:
+        return self["name"]
+
+    @property
+    def members(self) -> List[Dict[str, Any]]:
+        return list(self.get("members") or [])
+
+    @property
+    def online(self) -> Optional[Dict[str, Any]]:
+        return self.get("online")
+
+
+class ScorerGroupsClient:
+    def __init__(self, api_key: str, base_url: str):
+        self._api_key = api_key
+        self._base = base_url.rstrip("/") + "/agent-monitoring/scorer-groups"
+
+    def _request(self, method: str, url: str, json: Optional[Dict[str, Any]] = None) -> Any:
+        response = requests.request(
+            method,
+            url,
+            headers={"x-api-key": self._api_key, "content-type": "application/json"},
+            json=json,
+            timeout=30,
+        )
+        if response.status_code >= 400:
+            raise AgentXScorerGroupsError(f"HTTP {response.status_code}: {response.text}")
+        return response.json()
+
+    def list(self) -> List[ScorerGroup]:
+        return [ScorerGroup(g) for g in self._request("GET", self._base).get("scorerGroups", [])]
+
+    def get(self, group_id: str) -> ScorerGroup:
+        return ScorerGroup(self._request("GET", f"{self._base}/{group_id}")["scorerGroup"])
+
+    def create(
+        self,
+        name: str,
+        members: List[Dict[str, Any]],
+        description: Optional[str] = None,
+        online: Optional[Dict[str, Any]] = None,
+    ) -> ScorerGroup:
+        """``members``: [{"kind": "judge"|"pattern"|"custom", "refId": ..., "weight": 1, "gate": False}].
+        ``online``: {"enabled": True, "sampleRate": 0.1, "alertThreshold": 5, "severity": "medium"}
+        or None for offline-only."""
+        payload: Dict[str, Any] = {"name": name, "members": members}
+        if description is not None:
+            payload["description"] = description
+        if online is not None:
+            payload["online"] = online
+        return ScorerGroup(self._request("POST", self._base, json=payload)["scorerGroup"])
+
+    def update(self, group_id: str, **fields: Any) -> ScorerGroup:
+        """Sparse update - pass any of name/description/members/online (online=None detaches
+        live scoring)."""
+        return ScorerGroup(self._request("PUT", f"{self._base}/{group_id}", json=fields)["scorerGroup"])
+
+    def delete(self, group_id: str) -> None:
+        self._request("DELETE", f"{self._base}/{group_id}")
+
+    def ratings(self, group_id: str, window: str = "7d") -> Dict[str, Any]:
+        """Live score history for a group - ``{"window", "points": [{ts, averageRating, count}]}``,
+        the same shape online-evaluator ratings use. ``window``: "24h" | "7d" | "30d"."""
+        return self._request("GET", f"{self._base}/{group_id}/ratings?window={window}")

agentx/version.py

@@ -1,7 +1,7 @@
-VERSION = "0.8.14"
+VERSION = "0.8.16"
 
 # The AgentX-trace-eval release this SDK version is tested against - what `agentx-trace-eval`
 # installs and converges to (see agentx/cli.py). Bump together with VERSION when releasing, so
 # every published SDK names a known-good engine+dashboard pair. Users can override with
 # AGENTX_TRACE_EVAL_VERSION=<tag|latest>.
-ENGINE_VERSION = "v0.3.10"
+ENGINE_VERSION = "v0.3.13"

{agentx_python-0.8.14.dist-info → agentx_python-0.8.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.8.14
+Version: 0.8.16
 Summary: Official Python SDK for AgentX (https://www.agentx.so/)
 Home-page: https://github.com/AgentX-ai/AgentX-python
 Author: Robin Wang and AgentX Team

{agentx_python-0.8.14.dist-info → agentx_python-0.8.16.dist-info}/RECORD

@@ -10,17 +10,17 @@ agentx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentx/testing.py,sha256=0shZEid_vhJgBegpO_loUq6APYDxQrUgD3jvcRdIDV8,7372
 agentx/traces.py,sha256=sz9gxutlDKNgf0fdCkyzKsGwK5eMAJuIEl3NIwGrsuo,2287
 agentx/util.py,sha256=lt2Kpg4Fj8whrSuAhLEahcPEIYRVpK9RCC5y9ShdTJs,703
-agentx/version.py,sha256=ZCO46jAagFLJA2FF86tnlc0_wrjWmgCjw4xXMTEaj3w,366
+agentx/version.py,sha256=0obTIpPTOoMyuftj72non9y03CO044fCuNZQlNM6U3k,366
 agentx/evaluations/__init__.py,sha256=Erv7RGFlRxGTG4rVb2uHhCqLLEX_iAWKqkZKzK6CumE,262
 agentx/evaluations/_term.py,sha256=WFpiNzdgDBeJJ-Gg-6X7TwwxllobuE4OqFUTuDQvS3Y,2529
-agentx/evaluations/client.py,sha256=UlYl8OFmIjk8oqmL_LEpjnTn6CmUPBM1kgVgzkUKfT8,31999
+agentx/evaluations/client.py,sha256=f5GqsiuqknE-ENUYocBcXgV6OGMKdzmlsm76takJbwU,33112
 agentx/evaluations/datasets.py,sha256=2--V40JrSJoXxR1s0jI3i5rYT8ys25ouijqQQlj72D8,16053
 agentx/evaluations/evaluation_settings.py,sha256=geRydHqKpxwkxBVfMIOqkB6NlStyOZrYwZnMHluDwvA,6276
-agentx/evaluations/models.py,sha256=fKaDwyXhruXRHpBDw89Vv_FeceLvSILVrA9HNtzKLF8,32266
+agentx/evaluations/models.py,sha256=YUjo3glVMu9iaL9gwUt8bT2OewJGm_455ZiTwM6kaPo,32938
 agentx/evaluations/prompts.py,sha256=8xyvMpAl3mD5xuSZozuaohdnCBWe5Q02RldwiPLUO20,3493
 agentx/evaluations/reporting.py,sha256=GtNnL-1eNEQrSqd0yrHi5mGqC9_u0kUAN8Mbjdhw6yY,6389
 agentx/evaluations/results.py,sha256=w7TRUik4eXIqrznXvlF_L9hnObnHvgdRKvihfN1XeAU,4692
-agentx/evaluations/runner.py,sha256=qhaUiUaP_D5etjRnsuR71-uQGnwF_8J4LSPQ2lMWTU4,33882
+agentx/evaluations/runner.py,sha256=jPGWOHOEhTW6PK-qMK9X8i3EqldwEOh5jDk24lLVFEY,34744
 agentx/evaluations/tool_schemas.py,sha256=ZyrnSOnx9xlSAj4swfDey9ZLS2ly-g21DByTwRAGwNA,2323
 agentx/evaluations/tracing.py,sha256=MSJD9bzfInMi7E70mc8mWUc0fx5DLkOgUzRru2mNQoc,1825
 agentx/evaluations/adapters/__init__.py,sha256=fK8Hx75usbiY03XUSmnLnSrwBXip2CQs24YZcdEgj6w,287
@@ -43,14 +43,16 @@ agentx/integrations/openai.py,sha256=1KLs-hJaeW2emHPwNkmC3zcGksL3zd87uWbcLGRW704
 agentx/integrations/openai_agents.py,sha256=tCa3kPxqux5LnNNDQ6zA05OybQrjkc_LeE08YuNPJEs,12742
 agentx/monitor/__init__.py,sha256=MLiASSvQnCy2jqVNRTgPWFhUSf8lGYRQeEgEVVhE5Tg,574
 agentx/monitor/agents.py,sha256=8Xk4jWmNTvdtjFixHiLmw4jj96uqIXWIT6KW8zXoWrc,1006
-agentx/monitor/client.py,sha256=nY1cvjbCqL6BZMY6ubM-Q6JUKGgUM5CdBektV99EArQ,20812
-agentx/monitor/judge_scorers.py,sha256=Mu6OOnfjp1SRkZMcOyriO7zPawv-O2H2l2X-0io5WLM,15025
+agentx/monitor/client.py,sha256=qY3Dulnhsp_Izj7up4EIxYHRxOfbTVgysflTh2YRnPc,22543
+agentx/monitor/improvement_groups.py,sha256=-6-FcJnyiTLqeh9z8D9wyFD1QFqEsdDdDZdDJhC6QXw,3712
+agentx/monitor/judge_scorers.py,sha256=HKCPW_9QJeyGEGwWxr_clep9vn27bwJTKnjN5lYbuSk,15972
 agentx/monitor/models.py,sha256=yTC3WTdTziHMkdeAXlTro-4YiSbBUHMgf9kNZHGfPDA,8470
 agentx/monitor/online_evaluators.py,sha256=YWnsBmlIbYvj4LCaX4guwx4HS5y3oEzCQfo6ae9VH_w,8693
 agentx/monitor/patterns.py,sha256=ruBqLoA2T2KQuqRbbn1kWkIEkiOal3SvyPl9opGyhzI,4185
 agentx/monitor/profile.py,sha256=uGk-4bXT2vmnEQiY5u6rWhAfzZchHBXL74VD3piVHvU,3102
 agentx/monitor/review_queue.py,sha256=Tr3GDMJLJzyFKEEeB8HPmZBsNzzYVJYElDlfBC4qd68,3766
 agentx/monitor/rules.py,sha256=oLQ5RPgMPUKJFTSZzcBEMLzDlICElUNJTyIqxZMAGmQ,3040
+agentx/monitor/scorer_groups.py,sha256=qiQxo6NgNJ50ABKvL1S9OQXBQ-B_YFIiLR59FuXi0hg,3533
 agentx/monitor/scorers.py,sha256=huIZBszrfLKI8I7VV6NFpW6piRsj9HI03rXUwWs2tgs,7336
 agentx/monitor/sessions.py,sha256=gePcL284m3UITxQAtHxwrKFl6bRjmRib1QK6JbZeS9s,815
 agentx/monitor/signals.py,sha256=Ld11lW2lbg8NHBUHdgoY6iwCvJDK-eg4ge4qQ9y7nGY,1432
@@ -64,9 +66,9 @@ agentx/tracing/eval_scope.py,sha256=ElMbPxpqpQBVuaUnHNlw9RIQu71oyOpd0yR55bDH8eI,
 agentx/tracing/framework_detect.py,sha256=uV4O7Th-4_2UkdooAyaWCOIA0jwLJbblFQ_ucFDjeJM,2638
 agentx/tracing/ingest_client.py,sha256=spnm6bV3NXGuj2w7HwdKiJdKDJWRUFmSP3jl3rcGqkQ,18202
 agentx/tracing/tracer.py,sha256=TxY6zG6hbM81jpfrqP4imaEvoyy_hnJVUSTnoAVHMG0,56240
-agentx_python-0.8.14.dist-info/licenses/LICENSE,sha256=gZVsM-nLsE8vlaY6NXXsVoo6IlCClxkToAWmhgT3y_s,10762
-agentx_python-0.8.14.dist-info/METADATA,sha256=OT_i-6ZVjbcRjixhnL6vfo8wLdtmmkXhrjuxiEY1iRc,22117
-agentx_python-0.8.14.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-agentx_python-0.8.14.dist-info/entry_points.txt,sha256=rQqF1JTY3T1yfviBU1r8PU-5mBdfOk6P4bZ1L4BskIM,172
-agentx_python-0.8.14.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
-agentx_python-0.8.14.dist-info/RECORD,,
+agentx_python-0.8.16.dist-info/licenses/LICENSE,sha256=gZVsM-nLsE8vlaY6NXXsVoo6IlCClxkToAWmhgT3y_s,10762
+agentx_python-0.8.16.dist-info/METADATA,sha256=LRnDRYperDF64jcVdRcdtBH0Iwr5TtlTv0kLKbnC36o,22117
+agentx_python-0.8.16.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentx_python-0.8.16.dist-info/entry_points.txt,sha256=rQqF1JTY3T1yfviBU1r8PU-5mBdfOk6P4bZ1L4BskIM,172
+agentx_python-0.8.16.dist-info/top_level.txt,sha256=s-q-HB9Gb_QdrZNacSeQyF_c25gQooMy7DlxzgLOHPk,7
+agentx_python-0.8.16.dist-info/RECORD,,