TL;DR
Kimi Hosted Agents esegue attività IA multi-step con sessioni persistenti, esecuzione di strumenti e sandbox cloud. Questa guida ti porta da una chiave API di Kimi a una presentazione scaricabile di tre slide usando Bash, curl e jq. Completa prima un task con un prompt autosufficiente. Poi aggiungi un documento caricato, collega gli strumenti aziendali e gestisci gli errori rilevanti in un’applicazione distribuita.
Punti chiave
- Kimi Hosted Agents collega una definizione di agente, un ambiente di esecuzione e una sessione. Mantieni i loro ID disponibili per tutto il workflow.
- Inizia con un risultato piccolo e verificabile. Il primo esempio produce una presentazione con dati fittizi e un calcolo che puoi controllare.
- Usa il flusso di eventi per seguire l’esecuzione, poi ispeziona il file consegnato. Un successo HTTP da solo non dimostra il successo del task.
- Estendi l’esempio funzionante con input da file, strumenti personalizzati o servizi MCP. Ogni integrazione ha requisiti propri di esecuzione e credenziali.
- Pianifica insieme i costi di inferenza, runtime del sandbox e uso dei plugin, incluse le ripetizioni necessarie per ottenere un risultato accettabile.
Che cos’è Kimi Hosted Agents?
Moonshot AI ha annunciato Kimi Hosted Agents il 5 novembre 2026, posizionandolo come un servizio per imprese e sviluppatori che costruiscono agenti di lunga durata.
Il prodotto adotta un approccio Harness as a Service. Un harness è il software attorno a un modello che gestisce l’avanzamento del lavoro: mantiene lo stato, invoca strumenti, gestisce l’esecuzione e recupera da interruzioni.
Considera un workflow di ricerca settimanale. Generare testo è solo uno step. L’applicazione può anche dover recuperare fonti, elaborare file, creare grafici, salvare una presentazione e conservare abbastanza stato per continuare dopo una disconnessione.
Hosted Agents fornisce quello strato operativo. Il tuo team definisce comunque il task di business, seleziona le integrazioni e decide cosa costituisce un risultato accettabile.
L’architettura ufficiale di Kimi mostra l’applicazione, i servizi di piattaforma e il core di esecuzione usati dal runtime ospitato.
Capacità principali per la prima integrazione
- Le sessioni persistenti mantengono insieme input del task, eventi di esecuzione e output.
- I sandbox cloud forniscono gli strumenti necessari per elaborare file e creare deliverable.
- Le skill e i plugin impacchettano capacità riutilizzabili; strumenti personalizzati e servizi MCP collegano i tuoi sistemi.
Il primo checkpoint è una presentazione che puoi aprire e ispezionare. Le specifiche dettagliate del runtime diventano utili quando aggiungi dipendenze o sposti un workflow esistente nel sandbox; il sandbox reference documenta l’ambiente disponibile.
Cosa serve prima di chiamare l’API di Kimi Hosted Agents?
- Un account sulla piattaforma Kimi con accesso a Hosted Agents e una chiave API.
- Bash, curl e jq su macOS, Linux o Windows con WSL.
- Due terminali: il Terminale A invia le richieste; il Terminale B osserva gli eventi di esecuzione.
- Un visualizzatore di presentazioni per aprire il PPTX generato.
Crea un account sulla piattaforma Kimi e una chiave API nell’area di gestione API della console. Usa un terminale Bash, chiamato Terminale A, per i comandi di setup e di task. Tienilo aperto in modo che i passaggi successivi possano riutilizzare le sue variabili. Installa curl e jq prima di continuare. Gli esempi usano la versione beta dell’API 2026-09-01-beta.
command -v curl &&
command -v jq &&
read -rsp "Kimi API key: " KIMI_API_KEY &&
printf '\n' &&
test -n "$KIMI_API_KEY" &&
export KIMI_API_KEY &&
export KIMI_BASE="https://api.moonshot.cn/v1" &&
export KIMI_VERSION="2026-09-01-beta"
Come eseguire il primo task con Kimi Hosted Agents
Il workflow segue la guida rapida REST API di Kimi. Userai l’assistente PPT ufficiale per trasformare un breve briefing aziendale fittizio in una presentazione. Tutti i dati di input sono inclusi nella richiesta, quindi la prima esecuzione non richiede caricamento di file o connessioni a dati privati.
Esegui ogni blocco in ordine e controlla l’output prima di continuare. I comandi concatenati con && interrompono il blocco quando una richiesta o una validazione fallisce. Risolvi l’errore segnalato prima di passare allo step successivo; mantieni gli stessi ID di ambiente e di sessione quando ritenti un setup esistente.
Passo 1: selezionare l’assistente PPT ufficiale
Recupera gli agenti disponibili e ispeziona i loro nomi e definizioni. Quando richiesto, incolla l’ID dell’assistente PPT ufficiale configurato con le skill PPT. Il comando finale verifica che la tua selezione esista nell’elenco restituito e stampa la sua definizione.
curl --fail-with-body -sS "$KIMI_BASE/agents" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-o agents.json &&
jq -r '.items[] | [.id, .name] | @tsv' agents.json &&
read -rp "PPT assistant ID: " AGENT_ID &&
jq -e --arg id "$AGENT_ID" \
'.items[] | select(.id == $id)' agents.json &&
export AGENT_ID
Il comando finale dovrebbe stampare la definizione dell’agente selezionato. Se l’assistente non è disponibile nel tuo progetto, usa la configurazione dell’agente PPT ufficiale per preparare un agente equivalente prima di continuare.
Passo 2: creare un ambiente cloud
Un Environment è una configurazione riutilizzabile per il setup di esecuzione, incluse le librerie installate, l’accesso di rete e i comandi di avvio. Riutilizzarlo offre ai passaggi successivi lo stesso setup; ogni sessione cloud riceve comunque il proprio sandbox e workspace. Consulta la guida agli ambienti per le opzioni di configurazione.
Crea l’ambiente una volta e conserva il suo ID. Le immagini cloud si costruiscono in modo asincrono, quindi attendi finché lo stato di build non è ready prima di creare una sessione. Se l’API segnala che non è pronto, attendi e riprova con lo stesso ENVIRONMENT_ID. Creare un altro ambiente non completa la prima build.
curl --fail-with-body -sS "$KIMI_BASE/environments" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
-d '{"name":"First presentation environment","config":{"type":"cloud"}}' \
-o environment.json &&
ENVIRONMENT_ID="$(jq -er '.id | strings | select(length > 0)' environment.json)" &&
export ENVIRONMENT_ID &&
printf 'Environment: %s\n' "$ENVIRONMENT_ID"
Passo 3: creare una sessione
Una Session fissa la versione dell’Agent e una versione disponibile dell’Environment quando viene creata. La richiesta qui sotto fornisce i loro ID; la piattaforma seleziona e blocca le versioni. Puoi anche impostare agent_version per scegliere una versione esatta dell’Agent. Aggiornare l’Agent o l’Environment in seguito non aggiorna una sessione esistente, e una sessione non può cambiare il proprio environment_id. Crea una nuova sessione per usare configurazioni riviste. Queste regole sono documentate in creazione della sessione.
Conserva l’ID di sessione restituito sia per il flusso di eventi sia per le richieste di task. Una nuova sessione parte in idle; inviare user.message avvia il task.
test -n "$AGENT_ID" &&
test -n "$ENVIRONMENT_ID" &&
jq -n --arg agent "$AGENT_ID" --arg env "$ENVIRONMENT_ID" \
'{agent_id:$agent,environment_id:$env,title:"First product update presentation"}' \
> session-request.json &&
curl --fail-with-body -sS "$KIMI_BASE/sessions" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
--data-binary @session-request.json \
-o session.json &&
SESSION_ID="$(jq -er '.id | strings | select(length > 0)' session.json)" &&
export SESSION_ID &&
printf 'Session: %s\n' "$SESSION_ID"
Passo 4: osservare l’esecuzione in un secondo terminale
Apri il Terminale B. Inserisci la stessa chiave API, poi incolla l’ID della sessione stampato nel Terminale A. Il flusso di eventi server-sent mostra gli aggiornamenti di esecuzione mentre il Terminale A invia il task. Mantieni questo terminale connesso finché non hai ispezionato il risultato.
read -rsp "Kimi API key: " KIMI_API_KEY &&
printf '\n' &&
test -n "$KIMI_API_KEY" &&
read -rp "Session ID from Terminal A: " SESSION_ID &&
test -n "$SESSION_ID" &&
curl --fail-with-body -sS -N \
"https://api.moonshot.cn/v1/sessions/$SESSION_ID/events/stream" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: 2026-09-01-beta" \
-H "Accept: text/event-stream"
Passo 5: inviare un task autosufficiente
Torna al Terminale A e invia un evento user.message. L’esempio usa cifre fittizie e richiede un deliverable specifico. L’agente dovrebbe usare i fatti forniti anziché cercare dati aziendali di supporto.
cat > task.json <<'JSON' &&
{
"events": [{
"type": "user.message",
"data": {"content": [{
"type": "text",
"text": "Create a three-slide PPTX for a fictional product called Northstar. Use only these supplied facts: the pilot has 120 users; 90 were active this week; the team plans to interview 10 users next week. Slide 1: pilot overview. Slide 2: weekly activity, including the active-user percentage. Slide 3: next steps. Label the business and data as fictional. Do not browse the web. Save the presentation and register the PPTX as a downloadable artifact using save_artifact."
}]}
}]
}
JSON
curl --fail-with-body -sS "$KIMI_BASE/sessions/$SESSION_ID/events" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
--data-binary @task.json
Passo 6: scaricare e ispezionare la presentazione
Osserva i session.status nel Terminale B. Quando la sessione torna a idle, controlla il motivo di stop: end_turn indica che il turno è terminato, mentre requires_action significa che il tuo client deve fornire un risultato di uno strumento o gestire una conferma. Controlla anche gli eventi session.error. Dopo che il turno finisce senza errori irrisolti, elenca gli artifact e seleziona il PPTX generato.
curl --fail-with-body -sS "$KIMI_BASE/artifacts?session_id=$SESSION_ID" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-o artifacts.json &&
jq . artifacts.json &&
read -rp "PPTX artifact ID: " ARTIFACT_ID &&
test -n "$ARTIFACT_ID" &&
curl --fail-with-body -sS "$KIMI_BASE/artifacts/$ARTIFACT_ID/content" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-o northstar.pptx &&
printf 'Downloaded northstar.pptx\n'
Apri northstar.pptx. Un risultato riuscito ha tre slide, identifica i dati come fittizi e calcola l’attività settimanale come 90 ÷ 120 = 75%. Questo ti dà un controllo concreto sia sulla consegna del file sia sull’accuratezza dei contenuti prima di collegare dati aziendali reali.
Come caricare e associare file a una sessione di Kimi Hosted Agents?
Dopo che la prima presentazione funziona, posiziona un report.pdf di esempio nella directory di lavoro del Terminale A. La file API separa il caricamento di un file dall’associazione di quel file a una sessione. Esegui questo blocco con l’ID di sessione esistente dopo che il primo task è terminato.
Usa purpose=file-extract per estrarre testo dal PDF. La file API consente fino a 100 MiB per file e predefinisce 10 GiB di storage per organizzazione. I file caricati non possono essere aggiornati in-place; carica un file corretto e associa il suo nuovo ID. Rimuovi i file non utilizzati quando devi liberare spazio di archiviazione.
Con kimi-api-version: 2026-09-01-beta, controlla extract_status nella risposta di upload. Questo esempio procede solo quando è ready. Se è error, ispeziona il formato e i contenuti del PDF, poi carica un file corretto. L’API può associare un’estrazione fallita come file raw, ma ciò non fornisce il testo estratto che questo tutorial si aspetta. Uno stato mancante o inatteso interrompe il blocco; ispeziona upload.json prima di continuare.
test -f report.pdf &&
test -n "$SESSION_ID" &&
curl --fail-with-body -sS "$KIMI_BASE/files" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-F "file=@report.pdf" \
-F "purpose=file-extract" \
-o upload.json &&
FILE_ID="$(jq -er '.id | strings | select(length > 0)' upload.json)" &&
{
EXTRACT_STATUS="$(jq -r '.extract_status // "missing"' upload.json)" &&
case "$EXTRACT_STATUS" in
ready) true ;;
error)
printf '%s\n' 'PDF extraction failed. Check the PDF and upload a corrected file.' >&2
false ;;
*)
printf 'Unexpected extract_status: %s. Inspect upload.json before continuing.\n' "$EXTRACT_STATUS" >&2
false ;;
esac
} &&
jq -n --arg file "$FILE_ID" \
'{type:"file",file_id:$file}' > resource-request.json &&
curl --fail-with-body -sS "$KIMI_BASE/sessions/$SESSION_ID/resources" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
--data-binary @resource-request.json
Associare il file non invia un nuovo task. Mantieni il Terminale B connesso e invia un follow-up che nomini il documento e l’output desiderato.
jq -n --arg prompt \
"Use the attached report.pdf to create a new three-slide PPTX. Replace the earlier fictional brief. Summarize the report, its evidence, and its next steps. Do not invent missing figures or browse the web. Register the finished PPTX with save_artifact." \
'{events:[{type:"user.message",data:{content:[{type:"text",text:$prompt}]}}]}' \
> followup.json &&
curl --fail-with-body -sS "$KIMI_BASE/sessions/$SESSION_ID/events" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
--data-binary @followup.json
Quando questo task termina, ripeti lo step di elenco degli artifact e seleziona il nuovo PPTX. Confronta le sue affermazioni con il PDF, soprattutto numeri, date e azioni proposte.
Come collegare strumenti a Kimi Hosted Agents?
Strumenti personalizzati eseguiti dalla tua applicazione
Per un’azione di business come consultare lo stato di consegna di un progetto, usa un custom tool implementato dalla tua applicazione. Dichiarare lo strumento lo rende disponibile all’agente; il tuo codice esegue comunque l’operazione.
- Dichiara una voce
customnell’arraytoolsdell’agente con un nome, una descrizione e uninput_schemaa forma di oggetto. - Gestisci
agent.custom_tool_usedal flusso di eventi e valida gli argomenti forniti prima di eseguire la tua funzione. - Invia un evento
user.custom_tool_resultalla sessione, usando l’idJSON dell’evento chiamante comedata.event_id.
Inizia con una consultazione in sola lettura. Mantieni autorizzazioni e protezione contro azioni duplicate nell’applicazione quando un’integrazione può modificare record di business.
Servizi MCP e workflow più ampi
Per un servizio MCP remoto, dichiara la sua connessione in mcp_servers. Archivia le credenziali di accesso in un vault e associa quel vault quando crei la sessione. La piattaforma scopre e chiama gli strumenti del servizio; la definizione del server dovrebbe contenere dettagli di connessione anziché segreti.
Orchestrazione multi-agent facoltativa
La piattaforma supporta la delegazione coordinator-to-child. Un coordinator può assegnare task delimitati a thread figli e combinare i loro risultati.
La configurazione di delega accetta 1–20 agent entries. Questo è un limite di configurazione, non la prova di 20 worker simultanei o un miglioramento di velocità 20×. I thread figli non possono creare un altro livello di thread figli.
Un design utile potrebbe separare raccolta delle fonti, analisi quantitativa e revisione editoriale. Un task breve di sintesi di solito è gestito meglio da un solo agente.
Come distribuire un’integrazione con Kimi Hosted Agents?
Metti le chiamate all’API Kimi dietro il backend della tua applicazione. Il browser può inviare un task e mostrare l’avanzamento tramite i tuoi endpoint, mentre il backend conserva la chiave API e mappa ogni utente alle sessioni a cui è autorizzato ad accedere. Archivia l’ID di sessione con la richiesta di business così un ricaricamento della pagina può riaprire lo stesso task.
Esecuzione in hosting vs. autogestita
Usa un ambiente cloud per il workflow PPT di questa guida: supporta save_artifact e il workflow dei file di sessione. Scegli un ambiente autogestito quando l’esecuzione nel sandbox deve avvenire su un host gestito dalla tua organizzazione. Kimi esegue comunque l’inferenza del modello, l’orchestrazione e la gestione della sessione; gli input degli strumenti e i risultati passano attraverso la sua piattaforma. Questo è un modello di esecuzione ibrido.
- Gli ambienti autogestiti richiedono verifica enterprise. Operi l’host Worker, installi le sue dipendenze e gestisci isolamento e credenziali. Il Worker necessita di accesso HTTPS in uscita alla piattaforma.
- La modalità autogestita attualmente non dispone di
save_artifact, IPython e strumenti di ricerca immagini. I file caricati, le skill e la memoria non sono montati sul Worker, e i suoi file di output non compaiono nell’elenco file della sessione. Pianifica come fornire input e recuperare output prima di spostare questo tutorial in quella modalità.
Per una prima integrazione, inizia nel cloud. Considera l’autogestione quando il controllo sull’host di esecuzione giustifica il setup aggiuntivo e i cambiamenti nella consegna dei file.
Scelta di chi gestisce il runtime
Usa Hosted Agents quando vuoi che la piattaforma gestisca l’esecuzione della sessione. Se il tuo team deve costruire e gestire il proprio loop di agente, CometAPI fornisce accesso unificato alle API dei modelli per quello stack personalizzato. Gli esempi di Hosted Agents in questa guida usano gli endpoint e le credenziali di Kimi.
Prezzi e ottimizzazione dei costi di Kimi Hosted Agents
Kimi Hosted Agents addebita i token del modello, il runtime del sandbox cloud e le chiamate ai plugin a pagamento. La tabella sotto mostra come questi addebiti influiscono su un workflow di presentazione. I prezzi sono in yuan cinesi (CNY), verificati il 10 novembre 2026 rispetto ai prezzi di Hosted Agents e ai prezzi di inferenza del modello. Un milione di token equivale a 1 MTok.
| Componente di costo | Unità di fatturazione | Tariffa e cosa significa per il tuo task |
|---|---|---|
| Inferenza del modello | Per 1 MTok | Per kimi-k3.1-pro: input base ¥13, output ¥68, cache hits ¥1.30, scritture cache 5 minuti ¥13 e scritture cache 1 ora ¥26. Applica la tariffa per ciascuna categoria di utilizzo in tutte le chiamate al modello. |
| Sandbox cloud | Runtime; fatturato al secondo | ¥0.072/ora per un sandbox con 1 core CPU e 1 GB di memoria. Dieci minuti costano ¥0.012. |
| Plugin | Per chiamata fatturabile | Esempi: web search ¥0.03/chiamata; image search ¥0.045/chiamata. Altri plugin hanno le proprie tariffe. Moltiplica le chiamate di ciascun plugin per il prezzo indicato. |
| Costo totale del task | Per task completato | Somma addebiti di modello, sandbox e plugin. L’esempio di PPT lavorato sotto totalizza ¥0.544 senza chiamate a pagamento ai plugin, o ¥0.724 con tre web search e due image search agli stessi uso modello e runtime. |
La tariffa del modello è un esempio di budgeting per kimi-k3.1-pro, non un’affermazione che ogni Agent PPT ufficiale usi quel modello. Controlla la definizione del modello dell’Agent selezionato prima di applicare queste tariffe. Le tariffe per altri modelli e varianti ad alta velocità differiscono.
Come contare i token di input e output
Un Agent può chiamare il suo modello più volte mentre crea una presentazione. Somma l’uso fatturato di ogni chiamata, incluse le tornate successive e le revisioni. L’input può includere il prompt, testo estratto dal PDF, risultati degli strumenti e contesto della conversazione; l’uso di output non è limitato alle parole visibili sulle slide.
Per la cache K3, separa input non in cache, scritture in cache e cache hits. Sono categorie di input distinte: non addebitare l’intero totale di input alla tariffa base e poi aggiungere addebiti di cache per gli stessi token. Usa la tariffa di scrittura applicabile a 5 minuti o 1 ora. La guida alla fatturazione della cache spiega come conciliare queste categorie con l’uso riportato.
Esempio pratico: una presentazione di tre slide
Supponi che il tuo Agent usi kimi-k3.1-pro e che una esecuzione completa per una presentazione di tre slide consumi 20.000 token di input, 4.000 token di output fatturati e 10 minuti di runtime cloud fatturabile. Supponi nessun cache hit, nessuna scrittura cache a 1 ora e nessuna chiamata a plugin a pagamento. Tutto l’input è o non in cache o scritto nella cache predefinita a 5 minuti, entrambi al prezzo di ¥13/MTok. Queste sono quantità di utilizzo stimate per la pianificazione, non misure del tutorial Northstar.
| Addebito | Calcolo | Costo stimato |
|---|---|---|
| Input del modello | 20,000 ÷ 1,000,000 × ¥13 | ¥0.260 |
| Output del modello | 4,000 ÷ 1,000,000 × ¥68 | ¥0.272 |
| Sandbox cloud | 10 ÷ 60 × ¥0.072 | ¥0.012 |
| Plugin a pagamento | 0 chiamate fatturabili | ¥0.000 |
| Totale | ¥0.260 + ¥0.272 + ¥0.012 | ¥0.544 (circa ¥0.54) |
Il tutorial con fatti forniti chiede all’Agent di non navigare sul web. Se in seguito lo ampli a una presentazione di ricerca con tre web search e due image search, l’addebito del plugin sarebbe 3 × ¥0.03 + 2 × ¥0.045 = ¥0.180. Tenendo costanti le altre quantità ottieni ¥0.544 + ¥0.180 = ¥0.724. La ricerca può anche aumentare token del modello e runtime, quindi usa le quantità misurate per il conto finale.
Cosa cambia quando usi più agenti?
La delega può aggiungere chiamate al modello, contesto ripetuto, chiamate agli strumenti e lavoro di revisione. Il workflow multi-agent di Kimi pone il coordinator e i thread figli in una sessione. Il solo conteggio dei thread figli non è un moltiplicatore per gli addebiti del sandbox. Somma uso di modello e plugin attraverso i thread e usa il runtime effettivo fatturabile della sessione. Un’esecuzione più lunga o sessioni cloud aggiuntive indipendenti possono aumentare il costo del sandbox. Le FAQ spiegano che il tempo del sandbox smette di accumularsi quando tutti i thread finiscono e la sessione torna a idle.
Ridurre il costo per presentazione utilizzabile
Inizia con un solo Agent e un deliverable piccolo. Fornisci i passaggi di fonte rilevanti, limita il numero di slide e abilita le ricerche a pagamento solo quando il task ne ha bisogno. Riconnetti un flusso di eventi interrotto invece di inviare di nuovo lo stesso task. Per workflow ripetuti, ispeziona i cache hit e mantieni stabile il contesto riutilizzabile. Confronta il costo totale di tutti i tentativi con il numero di presentazioni che effettivamente accetti; una prima bozza economica che richiede diverse ripetizioni può costare di più complessivamente.
Risoluzione dei problemi comuni dell’API
- Autenticazione fallita: verifica che la chiave API sia impostata nel terminale che invia la richiesta e appartenga all’account previsto. Ispeziona l’errore HTTP prima di ripetere la chiamata.
- curl rifiuta un’opzione, o jq è assente: controlla le utilità installate. Questi esempi richiedono una versione di curl che supporti
--fail-with-bodye un eseguibile jq funzionante nello stesso ambiente Bash. - jq non può estrarre un ID: apri il JSON di risposta salvato. Potrebbe contenere un errore API invece di un oggetto di risorsa riuscito. Correggi prima la richiesta piuttosto che passare un ID vuoto al prossimo endpoint.
- Un workflow di strumenti personalizzati si arresta: ispeziona gli eventi degli strumenti in sospeso. Un motivo di stop
requires_actionsignifica che il client deve restituire un risultato di strumento o gestire una conferma prima che il thread interessato continui. - Le slide scaricate contengono affermazioni non supportate: confrontale con il briefing o il report fornito. Rivedi il task con la discrepanza specifica e ispeziona il prossimo deliverable prima di usarlo.
Registra l’endpoint, lo stato HTTP, l’ID di sessione e l’evento rilevante quando diagnostichi un errore. Mantieni le chiavi API fuori dai log diagnostici.
Conclusione
Inizia con un workflow completo di Kimi Hosted Agents: seleziona un agente, prepara il suo ambiente, crea una sessione, invia un task e ispeziona il file consegnato. Una volta che questo percorso funziona, aggiungi un documento sorgente e poi gli strumenti di business di cui la tua applicazione ha bisogno. Mantieni la progressione visibile e giudica ogni esecuzione dall’utilità del suo output, non solo dal fatto che la richiesta sia riuscita.
FAQ
Devo reinviare un task di Kimi Hosted Agents dopo una disconnessione?
No. Un flusso di eventi disconnesso non richiede un nuovo invio del task. Riconnettiti con il valore id: dell’ultimo frame SSE nell’header Last-Event-ID per riprendere la lettura. Questo valore è un cursore del flusso, non l’ID JSON dell’oggetto evento. Riconnettersi evita di inviare accidentalmente lo stesso lavoro due volte.
Cosa fare se un output di Kimi Hosted Agents manca dagli artifact?
Un file del sandbox può esistere senza essere registrato come artifact. Verifica se l’agente ha completato la presentazione e chiamato save_artifact. Se la registrazione manca, usa le API file della sessione per ispezionare la directory di output: GET /v1/sessions/{session_id}/filesystem?prefix=output. L’elenco copre una directory alla volta; aggiorna prefix per ispezionare una sottodirectory. Scarica il file scelto con GET /v1/sessions/{session_id}/filesystem/raw?path=output/northstar.pptx, sostituendo il percorso d’esempio con quello esatto restituito dall’elenco. Codifica l’URL del valore di query se il percorso contiene spazi o altri caratteri riservati. Includi gli stessi header di autorizzazione e versione API del tutorial.
L’aggiornamento di una configurazione di Kimi Hosted Agents cambia una sessione attiva?
No. Una sessione usa la versione dell’agente fissata alla creazione. Aggiornare l’agente crea una nuova versione per le sessioni successive, mentre le sessioni esistenti mantengono la configurazione originale. Per testare istruzioni o strumenti rivisti, avvia una nuova sessione e confronta il suo output con l’esecuzione precedente.

