LO STRATO DI ACCETTAZIONE PER IL LAVORO DEGLI AGENTI SU SCALA
Gli agenti spediscono lavoro più velocemente di quanto qualsiasi team possa revisionarlo. Il critico di SeaOtter assegna un punteggio a ogni artefatto e rimanda le correzioni finché non supera la Sua policy — agente↔critico, a velocità macchina.
ALLA SCALA DEGLI AGENTI
Un agente invia il lavoro per la valutazione. Viene instradato a un passaggio one-shot veloce — oppure a un controllo agentico profondo che esegue il lavoro in una sandbox e lo sonda. Un modello critico ostile decide, e Lei paga per il compute utilizzato. Poi allarghi lo sguardo: migliaia di agenti, valutati in parallelo, sincrono o asincrono.
FEEDBACK LOCALIZZATO
Il critico non dice solo che qualcosa è sbagliato. Localizza il problema così che l’agente possa rivedere la riga, la pagina, la slide, la cella, il frame o il timestamp esatto che ha fallito.
"Potrebbe esserci un problema da qualche parte in questo artefatto."
hallucinated_api · alto
self.tasks.add_item(task)add_item non è un metodo valido per list, quindi genera un’eccezione a runtime. Atteso self.tasks.append(task).
Una prima lettura, verificata su holdout, della capacità del nostro critico di fissare l’esatto intervallo e indicare il file. Il rilevamento è ancora in addestramento attivo; l’affermazione qui riguarda la qualità della localizzazione, non la critica generica.
INVIA → VALUTA
Un agente esegue una POST con il lavoro appena prodotto e SeaOtter lo valuta rispetto alla Sua policy di accettazione. I controlli piccoli e veloci restituiscono il verdetto inline. Quelli più pesanti restituiscono un job id che l’agente può sondare, streammare o ricevere via webhook — così una revisione lunga non blocca mai l’agente che l’ha richiesta.
PER LE PERSONE
Invii il lavoro alla casella SeaOtter e riceva una risposta con OtterScore, oppure lo incolli sul web e lo valuti nel browser. Nessun agente richiesto.
PER GLI AGENTI
Colleghi qualsiasi agente via HTTP o MCP così che valuti il proprio output nel ciclo — stessa policy, stesso OtterScore, a velocità macchina. Il quickstart da 60 secondi è qui sotto.
SINCRONO
Esegua una POST con il lavoro, mantenga la connessione e riceva il verdetto OtterScore — fascia, difetti, ancore, miglioramenti — nella stessa risposta. Ideale per un controllo one-shot nel ciclo interno dell’agente, quando serve la risposta prima del prossimo passo.
POST /api/v1/eval/score → 200 { band, flaws[], upgrades[] }
ASINCRONO
Esegua una POST con il lavoro, ottenga subito un job id, quindi esegua polling del job, si sottoscriva allo stream del risultato o registri un webhook. Ideale per un controllo agentico che esegue il lavoro in una sandbox su più passaggi — l’agente produttore prosegue e viene richiamato quando arriva il verdetto.
POST /api/v1/eval/jobs → 202 { job_id } · poll · stream (SSE) · webhook
Sync · one-shot
Un passaggio di critico ostile, restituito inline. Economico e a tariffa fissa.
curl -s https://dev-api.seaotter.ai/api/v1/eval/score \
-H "Authorization: Bearer $OTTER_KEY" -H 'Content-Type: application/json' \
-d '{ "mode":"one_shot", "modality":"text",
"policy_id":"acme-prod-acceptance",
"artifact_parts":[{"mime_type":"text/plain","text":"..."}] }'
# 200 { "band":"route_to_fix", "flaws":[...], "upgrades":[...] }Async · agentico
Il critico esegue il lavoro in una sandbox e lo sonda su più passaggi.
POST /api/v1/eval/jobs
{ "mode":"agentic", "modality":"code",
"policy_id":"acme-prod-acceptance",
"artifact_ref":"gs://...", "max_passes":6,
"webhook":"https://acme.internal/otter-callback" }
# 202 { "job_id":"job_8f21", "status":"running" }
GET /api/v1/eval/jobs/job_8f21 # poll, o stream, o attenda il webhookStessa policy, stesso OtterScore, stesso record di audit firmato — qualunque trasporto scelga l’agente.
PER AGENTI · MCP QUICKSTART
Tre passaggi: generi una chiave, aggiunga un server MCP, poi il Suo agente chiama otter_score / otter_iterate nel proprio ciclo — stesso OtterScore, stessa policy di accettazione, a velocità macchina. Il critico valuta; il Suo agente rivede in base ai difetti finché la fascia non supera il gate. È il ciclo che ha appena visto nella flotta sopra: ogni artefatto segnalato (route_to_fix, l’arco ambra) rientra nel gate via otter_iterate e viene rilasciato solo quando ready_to_ship è true. Nessun umano nel ciclo interno — la firma nominativa è l’ultimo gate, non l’unico.
Un utente dell’organizzazione con sessione attiva genera una volta la chiave di valutazione dell’agente. Il segreto sk-otter-… viene mostrato una sola volta; lo consegni all’agente.
Inserisca un server otterloop in .mcp.json (Claude / Cursor) o in config.toml (Codex). L’agente ottiene strumenti di critico in sola lettura che può approvare automaticamente.
L’agente invia il lavoro, legge i difetti ancorati, rivede e reinvia — iterando mentre ready_to_ship è false. Sopravvivere al critico È il prodotto.
1 — Registrazione
POST /api/v1/agent-keys con un JWT utente autenticato. Il segreto viene restituito una sola volta — oppure clicchi “Generate eval API key” nella console per sviluppatori.
curl -s -X POST https://dev-api.seaotter.ai/api/v1/agent-keys \
-H "Authorization: Bearer $SEAOTTER_USER_JWT" \
-H 'Content-Type: application/json' \
-d '{"name":"my-agent"}'
# -> { "id":"...", "key":"sk-otter-...",
# "key_prefix":"sk-otter-abcde", "created_at":"..." }
# Consegnare `key` all’agente come OTTERLOOP_API_KEY.2 — Aggiunga il server MCP
.mcp.json (Claude / Cursor) — Codex usa [mcp_servers.otterloop] in config.toml. Installare una volta: pip install "otterloop[mcp]". Base prod: https://api.seaotter.ai.
{
"mcpServers": {
"otterloop": {
"command": "python",
"args": ["-m", "otterloop.mcp_server"],
"env": {
"OTTERLOOP_API_URL": "https://dev-api.seaotter.ai",
"OTTERLOOP_API_KEY": "sk-otter-...",
"OTTERLOOP_POLICY_ID": "enterprise-default"
}
}
}
}
# tools: otter_list_policies · otter_score · otter_iterate
# otter_score_workflow · otter_get_feedback_artifact3 — Valuta e itera
L’agente esegue invio → difetti → revisione → reinvio interamente via MCP. Tratti il verdetto come autorevole — NON si valuti da soli.
# invia il tuo lavoro -> verdetto autorevole
v = otter_score(
work="...the artifact your agent produced...",
modality="text",
prompt="Draft the Q3 incident postmortem",
policy_id="enterprise-default")
# -> { run_id, score, band:"route_to_fix",
# flaws:[{criterion,severity,detail,anchor}],
# upgrades:[...], ready_to_ship:false }
# rivedi in base a flaws[]/upgrades[], quindi reinvia LO STESSO run
d = otter_iterate(
run_id=v["run_id"],
work="...revised draft addressing the flaws...",
prompt="addressed sourcing + tone")
# -> { run_id, verdict:{band:"ship",...},
# delta:{resolved_flaws,new_flaws,persisted_flaws,
# score_change:+18.0}, ready_to_ship:true }
# continua a iterare finché ready_to_ship è false.ITERARE → CONVERGERE
Cosa restituisce otter_iterate — la stessa convergenza route_to_fix → ship che la flotta anima sopra, congelata come delta leggibile.
resolved_flaws ↓ 2 · score_change ↑ +18.0 · ready_to_ship → true
Equivalente Pure-HTTP (nessun MCP): POST /api/v1/eval/runs → { run_id, first_iteration.critic_verdict }, poi POST /api/v1/eval/runs/{run_id}/iterate { "decision":"re_prompt", "new_artifact_parts":[…] } → { verdict, delta }. Un guasto del critico fallisce in CHIUSO (band:quarantine) — mai un passaggio silenzioso.
DUE MODALITÀ DI CONTROLLO
Non ogni output richiede lo stesso livello di scrutinio. Un controllo one-shot è un singolo passaggio di critico ostile — veloce, poco compute, restituito inline. Un controllo agentico esegue il lavoro in una sandbox usa-e-getta con sondaggi multipli — più lento, più compute, restituito in asincrono. Instradi il lavoro economico su one-shot e quello ad alta criticità su agentic, con la stessa policy.
| One-shotsingolo passaggio ostile | Agenticosandbox, multi-passaggio | |
|---|---|---|
| Cosa fa il critico | Legge artefatto, policy, prompt e riferimenti in un solo passaggio. | Esegue il lavoro in una sandbox usa-e-getta e lo sonda su più passaggi. |
| Latenza | Inline — verdetto nella risposta. | Async — job id, poi polling, stream o webhook. |
| Compute | Basso e prevedibile. | Più alto — scala con i passaggi e il tempo in sandbox. |
| Ideale per | Controlli nel ciclo interno, bozze ad alto volume, gate veloci. | Codice che deve girare, affermazioni da riprodurre, lavoro ad alto raggio d’azione. |
| Fatturazione | Economico, tariffa fissa per controllo. | A consumo in base a compute e tempo in sandbox. |
Entrambe le modalità restituiscono lo stesso verdetto OtterScore e scrivono lo stesso record di audit firmato.
PREZZI BASATI SULL'USO
Si paga per la valutazione effettivamente eseguita, non per numero di utenze. Un controllo one-shot è economico e a tariffa fissa; un controllo agentico è a consumo in base al compute e al tempo in sandbox. È ciò che rende economico valutare ogni output — e l’intera flotta — invece di razionare la revisione a un campione.
CONTROLLO ONE-SHOT
Economico, tariffa fissa
per controllo, fisso
Un singolo passaggio di critico ostile, restituito inline. Prezzi abbastanza bassi da stare nel ciclo interno di ogni agente e valutare bozze ad alto volume.
CONTROLLO AGENTICO
A consumo per compute
a consumo per compute + tempo in sandbox
Una revisione in sandbox e multi-passaggio. Si paga per i passaggi e il tempo in sandbox che il lavoro richiede realmente — riservi questa modalità agli output ad alta criticità, dove si ripaga.
La distribuzione enterprise resta shadow → enforce → managed; la valutazione a consumo misura il lavoro sottostante. Un preventivo concreto in £ è disponibile su richiesta.
INFRASTRUTTURA OTTERLOOP
Qualsiasi agente emette lavoro: codice, testo, immagine, deck, foglio, video o un’intera traiettoria.
SeaOtter lo valuta rispetto alla rubrica corretta e alla soglia condizionata alla Sua organizzazione.
Il verdetto restituisce difetti, miglioramenti e ancore che l’agente può colpire direttamente.
L’agente riscrive l’artefatto o il prossimo passo usando il controargomento del critico.
Il ciclo si ferma solo quando la fascia supera il gate e l’evidenza di audit è scritta.
MCP
Inserisca in `.mcp.json` o `config.toml` per Claude, Codex, Cursor o un runtime personalizzato.
{ "mcpServers": { "otterloop": {
"command": "python", "args": ["-m", "otterloop.mcp_server"],
"env": { "OTTERLOOP_API_URL": "https://dev-api.seaotter.ai",
"OTTERLOOP_API_KEY": "sk-otter-...",
"OTTERLOOP_POLICY_ID": "acme-prod-acceptance" } } } }curl
Qualsiasi runtime che parli HTTP può valutare una volta o restare nel ciclo.
curl -s https://dev-api.seaotter.ai/api/v1/eval/feedback \
-H "Authorization: Bearer $OTTER_KEY" -H 'Content-Type: application/json' \
-d '{ "modality":"text", "policy_id":"acme-prod-acceptance", "locale":"ja",
"prompt":"Draft the Q3 incident postmortem",
"artifact_parts":[{"mime_type":"text/plain","text":"..."}],
"return_feedback_artifacts": true }'Python SDK
Una chiamata di loop guida produci → valuta → rivedi finché il critico dice di rilasciare.
from otterloop import OtterLoopClient otter = OtterLoopClient(policy_id="acme-prod-acceptance", locale="ja") final = otter.loop(produce=lambda feedback: my_agent.revise(feedback), work=my_agent.first_draft(), modality="document", references=["file://brand-guide.pdf", "file://gold-postmortem.md"], max_rounds=5, target_band="ship")