v0.5.0

Session-level evals

• Multi-turn eval cases: input may be a list of turns; they run as one session, so later turns see earlier history and recovery across a conversation is evaluable.
• New handoff grader: passes only if the session actually escalated to a human, so "hands off on hardship" is testable end-to-end (5 graders total: exact, contains, tool_called, handoff, judge).
• Judge grades in full context: the agent's system prompt and the whole conversation, with one line of reasoning before the verdict, kept in the report as judge_output.
• Per-cohort strictness: strict (default, any doubt fails; right for compliance cohorts) or lenient (for tone/style cohorts).
• Judge independence: the runner warns when the judge model is the agent's own model; docs recommend a different model family.

Docs and playbooks

• Playbooks updated to gpt-5.6: agents on gpt-5.6-sol, judges on gpt-5.6-terra; escalation cases moved to session-level handoff cohorts.

All changes are backward compatible with existing cohort YAML.

v0.4.1

Ops hygiene for long-running deployments

Clean shutdown everywhere. aclose() on both bridge adapters, WebhookBackend, WebhookChannel, and ElevenLabsChannel, plus AgentApp.aclose() (unwraps the redactor, closes pooled and injected adapters and the handover backend) and ChannelHub.aclose(). Embedders that build and discard apps (tests, notebooks, workers) no longer leak connection pools.

Production metrics stay production. scorecard and feedback auto-capture skip eval-/synthetic- prefixed sessions by default (opt out via exclude_session_prefixes), so CI runs and nightly synthetics can't pollute SARR.

Redacted training exports. export_dataset(redactor=...) and zolva export-dataset --redaction mask PII in the fine-tuning JSONL while the database keeps the true transcripts.

Blocked channel traffic escalates. A guardrail block at the channel boundary now routes through the public AgentApp.escalate(), the same degrade-to-humans contract as blocks inside the agent loop.

Also: PyPI sidebar links (docs, repo, changelog, issues) in the project metadata.

249 tests, mypy --strict, ruff, bandit clean.

v0.4.0

Production hardening for real deployments

PII redaction before any provider call. Enable builtin patterns (card, email, phone, aadhaar, ssn) plus your own regexes; only the masked copy reaches the LLM, while sessions, audit, and human handover keep the true transcript.

app = AgentApp.from_config("agents/", redaction="policies/redaction.yaml")

Provider resilience. Transient 429/5xx and transport errors retry with bounded backoff (honoring Retry-After) instead of escalating a customer. model: config gains base_url and timeout for in-house gateways, with per-gateway connection pools.

zolva serve. Reference HTTP entrypoint for channels: HMAC-verified POST /channels/{channel}/{agent}, /healthz, behind the existing [dashboard] extra. Config to a running webhook endpoint in one command.

Human loop, closed. AgentApp.resume() records a teammate's resolution as an audited resume step and a session note, so the agent knows the outcome when the customer returns. Exposed as HMAC-verified POST /sessions/{agent}/resume.

Per-customer contact caps. Pass customer_ref on run() or channel payloads and cap contact frequency across sessions and channels in policy:

post:
  - block_contact_frequency: { max_contacts: 3, window_hours: 168, ledger: contacts.sqlite }

Pluggable audit storage. The hash chain now sits on the four-method AuditStore protocol (SQLite default, in-memory reference; Postgres is the same four methods). verify() stays full-from-genesis by default; monitors use verify(incremental=True) with a periodic full pass, exactly what the dashboard does.

240 tests, mypy --strict, ruff, bandit clean.

v0.3.2

Dashboard

pip install "zolva[dashboard]" then zolva dashboard agents/ --audit audit.sqlite: a self-hosted, read-only web UI over your agent configs and the hash-chained audit log. Agent/tool/handoff topology, a live-tailing paginated session feed with full step transcripts (queries in, model/tool calls out), tool-call stats, the SARR scorecard, and a continuous chain-verification badge. The audit DB is opened read-only; one self-contained HTML file, no CDN, works air-gapped.

• Try it without installing: static demo at https://zolva.ai/demo/
• Architecture and API reference: https://zolva.ai/docs/dashboard/
• Seeded demo dataset: python examples/dashboard_demo/seed.py (+ live.py to watch the live tail move)

Hardening (from a full-package audit)

• get_adapter now lazily imports built-in providers — openai/anthropic resolve without a manual side-effect import (previously real conversations escalated with "unknown provider")
• Declared-but-unregistered tools fail at AgentApp construction with ConfigError, not mid-conversation
• A crashing bus hook (e.g. audit disk failure) fails closed to human handover instead of crashing the run
• A down handover backend logs critical and still returns the blocked message — never silence
• zolva validate now runs startup-parity checks: guardrail policy shapes and declared eval cohorts
• Audit log gains a session_id index; AuditLog.append accepts a ts override for backfill

188 tests, mypy --strict, ruff clean.

v0.3.1

Packaging-only patch: the sdist now contains just the package sources, tests, and examples (54K, was 5.5M). No code changes from 0.3.0.

v0.3.0

Security and reliability hardening plus three roadmap features. 163 tests, ruff + mypy --strict clean.

Fixes

• Per-agent tool allowlist enforced at dispatch (undeclared tools can no longer execute)
• One bridge adapter / httpx client per provider per app (was: new unclosed client per model call)
• Malformed provider responses degrade to human handover instead of crashing (BridgeError wrapping)
• Eval reruns no longer inherit prior session history (unique session ids)
• Audit/session sqlite appends safe under multi-worker deployments (immediate transactions + busy timeout)
• Sync tools run on worker threads; a slow bank API no longer stalls concurrent sessions (make tools thread-safe, or declare them async def)
• Clean CLI errors for bridge failures; cohort files validated before feedback promotion; ci.yml actions SHA-pinned

Features

• evals: auto-wired from agent YAML; zolva eval --agents <config_dir> --gate (fails loudly on zero or missing cohorts)
• zolva synthetics subcommand with --gate for cron/CI patrol
• zolva.signing with receiver-side verify_zolva_signature (wire format unchanged)

v0.2.0: customer channels

Channels: one CX endpoint per declared channel

• ChannelHub: declare customer channels in channels.yaml; any agent becomes reachable on its allowed channels. Per-agent channel allowlists, per-channel session namespacing, and both message directions emitted on the bus as channel steps (audited customer contact).
• Adapters: webhook (HMAC-signed delivery, replay-resistant), log (dev), fake (scripted, for tests), and elevenlabs (voice: documented TTS endpoint, signed audio delivery to your call gateway, plus a webhook-signature verification helper).
• zolva.config.resolve_refs is now public for plugin config loading.
• 132 tests, mypy --strict, 3-version CI matrix. Runtime deps unchanged: pydantic, httpx, pyyaml.

Playbooks for voice CX (ElevenLabs), WhatsApp collections, and CI gating: https://zolva.ai/playbooks/

Install: pip install zolva==0.2.0

v0.1.2 (beta)

fix: zolva eval --app module:app now imports from the current directory (console-script entry points don't put CWD on sys.path). Found in isolated field testing of the built wheel. No API changes.

v0.1.1 (beta)

README/branding: project mark now renders on the PyPI page. No code changes.

v0.1.0 (beta)

First public beta of Zolva, the open-source, self-hosted agent platform for banks and fintechs.

• Declarative agents (YAML + Markdown), typed tool contracts, vendor-neutral LLM bridge (OpenAI, Anthropic, scripted Fake for tests)
• Guardrails: contact windows, required disclaimers, fail-closed judge rules; policies validate at startup and auto-attach from agent YAML
• Evals: golden datasets, four graders, worst-cohort CI gate (zolva eval --gate)
• Feedback loop: escalations auto-captured, failures promoted to permanent eval cases, fine-tuning JSONL export
• Audit: hash-chained tamper-evident log, SARR scorecard
• Synthetics: persona LLMs patrol critical paths against the real agent
• Human handover: HMAC-signed webhooks with replay-resistant timestamps

105 tests, mypy --strict, ruff. APIs may change before 1.0.