TL;DR
Kimi Hosted Agents ejecuta tareas de IA en múltiples pasos con sesiones persistentes, ejecución de herramientas y sandboxes en la nube. Esta guía te lleva desde una clave de API de Kimi hasta una presentación descargable de tres diapositivas usando Bash, curl y jq. Primero completa una tarea con un prompt autosuficiente. Luego agrega un documento cargado, conecta herramientas de negocio y maneja los fallos que importan en una aplicación desplegada.
Puntos clave
- Kimi Hosted Agents conecta una definición de agente, un entorno de ejecución y una sesión. Mantén sus IDs disponibles durante todo el flujo de trabajo.
- Comienza con un resultado pequeño y verificable. El primer ejemplo produce una presentación con datos ficticios y un cálculo que puedes comprobar.
- Usa el stream de eventos para seguir la ejecución y luego inspecciona el archivo entregado. Una respuesta HTTP exitosa por sí sola no establece el éxito de la tarea.
- Extiende el ejemplo funcional con entradas de archivos, herramientas personalizadas o servicios MCP. Cada integración tiene sus propios requisitos de ejecución y credenciales.
- Presupuesta juntos la inferencia, el tiempo de ejecución del sandbox y el uso de plugins, incluyendo las repeticiones necesarias para obtener un resultado aceptable.
¿Qué es Kimi Hosted Agents?
Moonshot AI anunció Kimi Hosted Agents el 5 de noviembre de 2026, posicionándolo como un servicio para empresas y desarrolladores que construyen agentes de larga duración.
El producto utiliza un enfoque de Harness como servicio. Un harness es el software alrededor de un modelo que gestiona cómo progresa el trabajo: mantiene estado, invoca herramientas, gestiona la ejecución y se recupera de interrupciones.
Considera un flujo de trabajo semanal de investigación. Generar texto es solo un paso. La aplicación también puede necesitar recuperar fuentes, procesar archivos, crear gráficos, guardar una presentación y conservar suficiente estado para continuar tras una desconexión.
Hosted Agents aporta esa capa operativa. Tu equipo sigue definiendo la tarea de negocio, selecciona integraciones y decide qué constituye un resultado aceptable.
La arquitectura oficial de Kimi muestra la aplicación, los servicios de plataforma y el núcleo de ejecución usados por el runtime hospedado.
Capacidades clave para tu primera integración
- Las sesiones persistentes mantienen juntos las entradas de la tarea, los eventos de ejecución y las salidas.
- Los sandboxes en la nube proporcionan las herramientas necesarias para procesar archivos y crear entregables.
- Las Skills y plugins empaquetan capacidades reutilizables; las herramientas personalizadas y servicios MCP conectan tus propios sistemas.
Tu primer punto de control es una presentación que puedas abrir e inspeccionar. Las especificaciones de runtime detalladas se vuelven útiles cuando agregas dependencias o mueves un flujo de trabajo existente al sandbox; la referencia del sandbox documenta el entorno disponible.
¿Qué necesitas antes de llamar al API de Kimi Hosted Agents?
- Una cuenta en la plataforma Kimi con acceso a Hosted Agents y una clave de API.
- Bash, curl y jq en macOS, Linux o Windows con WSL.
- Dos terminales: el Terminal A envía solicitudes; el Terminal B observa los eventos de ejecución.
- Un visor de presentaciones para abrir el PPTX generado.
Crea una cuenta en la plataforma Kimi y una clave de API en el área de gestión de API de la consola. Usa un terminal Bash, llamado Terminal A, para los comandos de configuración y de tarea. Mantenlo abierto para que pasos posteriores puedan reutilizar sus variables. Instala curl y jq antes de continuar. Los ejemplos usan la versión beta del 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"
¿Cómo ejecutar tu primera tarea de Kimi Hosted Agents?
El flujo de trabajo sigue el quickstart del API REST de Kimi. Usarás el asistente oficial de PPT para convertir un breve resumen ficticio de negocio en una presentación. Todos los datos de entrada están incluidos en la solicitud, por lo que la primera ejecución no necesita carga de archivos ni conexión a datos privados.
Ejecuta cada bloque en orden y verifica su salida antes de continuar. Los comandos unidos por && detienen ese bloque cuando una solicitud o validación falla. Resuelve el error reportado antes de pasar al siguiente paso; mantén los mismos IDs de entorno y sesión cuando reintentes una configuración existente.
Paso 1: Selecciona el asistente oficial de PPT
Obtén los agentes disponibles e inspecciona sus nombres y definiciones. Cuando se te solicite, pega el ID del asistente oficial de PPT configurado con habilidades de PPT. El comando final comprueba que tu selección existe en la lista devuelta e imprime su definición.
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
El comando final debería imprimir la definición del agente seleccionado. Si el asistente no está disponible en tu proyecto, usa la configuración oficial del agente de PPT para preparar un agente equivalente antes de continuar.
Paso 2: Crea un entorno en la nube
Un Environment es una configuración reutilizable para tu setup de ejecución, incluyendo paquetes instalados, acceso a red y comandos de inicio. Reutilizarlo da a las sesiones posteriores el mismo setup; cada sesión en la nube aún recibe su propio sandbox y espacio de trabajo. Consulta la guía de entornos para opciones de configuración.
Crea el entorno una vez y conserva su ID. Las imágenes en la nube se construyen de forma asíncrona, así que espera hasta que su estado de build sea ready antes de crear una sesión. Si el API informa que no está listo, espera y reintenta con el mismo ENVIRONMENT_ID. Crear otro entorno no finaliza la primera 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"
Paso 3: Crea una sesión
Una Session fija la versión del Agent y una versión disponible del Environment cuando se crea. La solicitud de abajo proporciona sus IDs; la plataforma selecciona y congela las versiones. También puedes establecer agent_version para elegir una versión exacta del Agent. Actualizar el Agent o el Environment más tarde no actualiza una sesión existente, y una sesión no puede cambiar su environment_id. Crea una nueva sesión para usar configuraciones revisadas. Estas reglas están documentadas en la creación de sesiones.
Conserva el ID de sesión devuelto tanto para el stream de eventos como para las solicitudes de tarea. Una sesión nueva inicia en idle; enviar user.message inicia la tarea.
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"
Paso 4: Observa la ejecución en un segundo terminal
Abre el Terminal B. Ingresa la misma clave de API y luego pega el ID de sesión impreso en el Terminal A. El stream de eventos enviados por el servidor muestra actualizaciones de ejecución mientras el Terminal A envía la tarea. Mantén este terminal conectado hasta que hayas inspeccionado el resultado.
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"
Paso 5: Envía una tarea autosuficiente
Regresa al Terminal A y envía un evento user.message. El ejemplo usa cifras ficticias y solicita un entregable específico. El agente debe usar los hechos proporcionados en lugar de buscar datos de negocio de apoyo.
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
Paso 6: Descarga e inspecciona la presentación
Observa en el Terminal B los eventos session.status. Cuando la sesión regrese a idle, inspecciona su razón de parada: end_turn indica que el turno ha terminado, mientras que requires_action significa que tu cliente debe proporcionar el resultado de una herramienta o gestionar una confirmación. Revisa también los eventos session.error. Tras finalizar el turno sin un error no resuelto, lista los artifacts y selecciona el PPTX generado.
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'
Abre northstar.pptx. Un resultado exitoso tiene tres diapositivas, identifica los datos como ficticios y calcula la actividad semanal como 90 ÷ 120 = 75%. Esto te da una comprobación concreta tanto de la entrega del archivo como de la exactitud del contenido antes de conectar datos reales de negocio.
¿Cómo subir y adjuntar archivos a una sesión de Kimi Hosted Agents?
Después de que funcione la primera presentación, coloca un report.pdf de muestra en el directorio de trabajo del Terminal A. El API de archivos separa la subida de un archivo de su adjunción a una sesión. Ejecuta este bloque con el ID de sesión existente después de que la primera tarea haya terminado.
Usa purpose=file-extract para extraer texto del PDF. El API de archivos permite hasta 100 MiB por archivo y por defecto 10 GiB de almacenamiento por organización. Los archivos subidos no se pueden actualizar in situ; sube un archivo revisado y vincula su nuevo ID. Elimina archivos no utilizados cuando necesites liberar almacenamiento.
Con kimi-api-version: 2026-09-01-beta, revisa extract_status en la respuesta de subida. Este ejemplo procede solo cuando es ready. Si es error, inspecciona el formato y contenido del PDF, luego sube un archivo corregido. El API puede adjuntar una extracción fallida como archivo bruto, pero eso no proporciona el texto extraído que este tutorial espera. Un estado faltante o inesperado también detiene el bloque; inspecciona upload.json antes de continuar.
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
Adjuntar el archivo no envía una nueva tarea. Mantén conectado el Terminal B y envía un seguimiento que nombre el documento y el resultado deseado.
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
Cuando esta tarea termine, repite el paso de listado de artifacts y selecciona el nuevo PPTX. Compara sus afirmaciones con el PDF, especialmente cualquier número, fecha y acciones propuestas.
¿Cómo conectar herramientas a Kimi Hosted Agents?
Herramientas personalizadas ejecutadas por tu aplicación
Para una acción de negocio como consultar el estado de entrega de un proyecto, usa una herramienta personalizada implementada por tu aplicación. Declarar la herramienta la hace disponible para el agente; tu código aún realiza la operación.
- Declara una entrada
customen el arraytoolsdel agente con un nombre, descripción yinput_schemacon forma de objeto. - Maneja
agent.custom_tool_usedesde el stream de eventos y valida los argumentos proporcionados antes de ejecutar tu función. - Publica un evento
user.custom_tool_resulten la sesión, usando elidJSON del evento que llamó comodata.event_id.
Comienza con una consulta de solo lectura. Mantén la autorización y la protección contra acciones duplicadas en la aplicación cuando una integración pueda modificar registros de negocio.
Servicios MCP y flujos de trabajo más grandes
Para un servicio MCP remoto, declara su conexión en mcp_servers. Almacena las credenciales de acceso en un vault y vincula ese vault al crear la sesión. La plataforma descubre y llama a las herramientas del servicio; la definición del servidor debe contener detalles de conexión en lugar de secretos.
Orquestación opcional multiagente
La plataforma admite la delegación de coordinador a hijos. Un coordinador puede asignar tareas acotadas a hilos hijos y combinar sus resultados.
Su configuración de delegación acepta entre 1–20 entradas de agentes. Este es un límite de configuración, no evidencia de 20 trabajadores simultáneos ni una mejora de velocidad de 20×. Los hilos hijos no pueden crear otra capa de hilos hijos.
Un diseño útil podría separar la recopilación de fuentes, el análisis cuantitativo y la revisión editorial. Una tarea de resumen corta suele manejarse mejor por un solo agente.
¿Cómo desplegar una integración de Kimi Hosted Agents?
Pon las llamadas al API de Kimi detrás del backend de tu aplicación. El navegador puede enviar una tarea y mostrar el progreso a través de tus propios endpoints, mientras el backend conserva la clave de API y asigna a cada usuario las sesiones a las que tienen permiso de acceso. Almacena el ID de sesión con la solicitud de negocio para que una recarga de página pueda reabrir la misma tarea.
Ejecución hospedada vs. autohospedada
Usa un entorno en la nube para el flujo de trabajo de PPT de esta guía: admite save_artifact y el flujo de archivos de sesión. Elige un entorno autohospedado cuando la ejecución del sandbox deba funcionar en un host que gestione tu organización. Kimi aún ejecuta la inferencia del modelo, la orquestación y la gestión de sesiones; las entradas y resultados de herramientas pasan por su plataforma. Este es un modelo de ejecución híbrido.
- Los entornos autohospedados requieren verificación empresarial. Operas el host Worker, instalas sus dependencias y gestionas aislamiento y credenciales. El Worker necesita acceso HTTPS saliente a la plataforma.
- El modo autohospedado actualmente carece de
save_artifact, IPython y herramientas de búsqueda de imágenes. Los archivos subidos, skills y memoria no se montan en el Worker, y sus archivos de salida no aparecen en la lista de archivos de la sesión. Planifica cómo suministrar entradas y recuperar salidas antes de mover este tutorial a ese modo.
Para una primera integración, comienza en la nube. Considera el autohospedaje cuando el control sobre el host de ejecución justifique la configuración adicional y los cambios en la entrega de archivos.
Elegir quién opera el runtime
Usa Hosted Agents cuando quieras que la plataforma gestione la ejecución de la sesión. Si tu equipo necesita construir y operar su propio loop de agente, CometAPI proporciona acceso unificado al API de modelos para ese stack personalizado. Los ejemplos de Hosted Agents en esta guía usan los endpoints y credenciales propios de Kimi.
Precios y optimización de costos de Kimi Hosted Agents
Kimi Hosted Agents cobra por tokens del modelo, runtime del sandbox en la nube y llamadas a plugins de pago. La tabla de abajo muestra cómo esos cargos afectan un flujo de trabajo de presentación. Los precios están en yuanes chinos (CNY), verificados el 10 de noviembre de 2026 contra los precios de Hosted Agents y los precios de inferencia de modelos. Un millón de tokens equivale a 1 MTok.
| Componente de costo | Unidad de facturación | Tarifa y lo que significa para tu tarea |
|---|---|---|
| Inferencia del modelo | Por 1 MTok | Para kimi-k3.1-pro: entrada base ¥13, salida ¥68, aciertos de caché ¥1.30, escrituras de caché de 5 minutos ¥13 y escrituras de caché de 1 hora ¥26. Aplica la tarifa para cada categoría de uso en todas las llamadas al modelo. |
| Sandbox en la nube | Runtime; facturado por segundo | ¥0.072/hora para un sandbox con 1 núcleo de CPU y 1 GB de memoria. Diez minutos cuestan ¥0.012. |
| Plugins | Por llamada facturable | Ejemplos: búsqueda web ¥0.03/llamada; búsqueda de imágenes ¥0.045/llamada. Otros plugins tienen sus propias tarifas. Multiplica las llamadas de cada plugin por su precio listado. |
| Costo total de la tarea | Por tarea completada | Suma cargos de modelo, sandbox y plugins. El ejemplo trabajado de PPT abajo totaliza ¥0.544 sin llamadas de plugins de pago, o ¥0.724 con tres búsquedas web y dos búsquedas de imágenes con el mismo uso de modelo y runtime asumido. |
La tarifa del modelo es un ejemplo de presupuestación para kimi-k3.1-pro, no una afirmación de que cada agente oficial de PPT use ese modelo. Revisa la definición del modelo del Agent seleccionado antes de aplicar estas tarifas. Las tarifas para otros modelos y variantes de alta velocidad difieren.
Cómo contar tokens de entrada y salida
Un Agent puede llamar a su modelo varias veces mientras crea una presentación. Suma el uso facturado de cada llamada, incluyendo turnos de seguimiento y revisiones. La entrada puede incluir el prompt, el texto extraído del PDF, resultados de herramientas y el contexto de la conversación; el uso de salida no se limita a las palabras visibles en las diapositivas.
Para el caching de K3, separa la entrada no cacheada, las escrituras de caché y los aciertos de caché. Estas son categorías de entrada distintas: no cobres el total de entrada completo a la tarifa base y luego agregues cargos de caché por los mismos tokens. Usa la tarifa aplicable de escritura de 5 minutos o de 1 hora. La guía de facturación de caché explica cómo conciliar estas categorías con el uso reportado.
Ejemplo trabajado: una presentación de tres diapositivas
Supón que tu Agent usa kimi-k3.1-pro y una ejecución completa de PPT de tres diapositivas consume 20,000 tokens de entrada, 4,000 tokens de salida facturados y 10 minutos de runtime facturable en la nube. Supón sin aciertos de caché, sin escrituras de caché de 1 hora y sin llamadas a plugins de pago. Toda la entrada es o bien no cacheada o escrita en la caché por defecto de 5 minutos, ambas con precio de ¥13/MTok. Estas son cantidades de uso estimadas para la planificación, no mediciones del tutorial de Northstar.
| Cargo | Cálculo | Costo estimado |
|---|---|---|
| Entrada del modelo | 20,000 ÷ 1,000,000 × ¥13 | ¥0.260 |
| Salida del modelo | 4,000 ÷ 1,000,000 × ¥68 | ¥0.272 |
| Sandbox en la nube | 10 ÷ 60 × ¥0.072 | ¥0.012 |
| Plugins de pago | 0 llamadas facturables | ¥0.000 |
| Total | ¥0.260 + ¥0.272 + ¥0.012 | ¥0.544 (aprox. ¥0.54) |
El tutorial de hechos suministrados pide al Agent que no navegue por la web. Si luego lo amplías a una presentación de investigación con tres búsquedas web y dos búsquedas de imágenes, el cargo de plugins sería 3 × ¥0.03 + 2 × ¥0.045 = ¥0.180. Manteniendo constantes las otras cantidades da ¥0.544 + ¥0.180 = ¥0.724. La investigación también puede aumentar los tokens del modelo y el runtime, así que usa las cantidades medidas para la factura final.
¿Qué cambia cuando usas múltiples agentes?
La delegación puede agregar llamadas de modelo, contexto repetido, llamadas a herramientas y trabajo de revisión. El flujo de trabajo multiagente de Kimi coloca el coordinador y los hilos hijos en una sola sesión. El recuento de hilos hijos por sí solo no es un multiplicador para los cargos del sandbox. Suma el uso de modelo y plugins en todos los hilos, y usa el runtime facturable real de la sesión. Una ejecución más larga o sesiones en la nube adicionales e independientes pueden incrementar el costo del sandbox. El FAQ explica que el tiempo del sandbox deja de acumularse cuando todos los hilos finalizan y la sesión pasa a idle.
Reduce el costo por presentación utilizable
Empieza con un solo Agent y un entregable pequeño. Proporciona los pasajes de fuente relevantes, limita el número de diapositivas y habilita búsquedas de pago solo cuando la tarea las necesite. Reconecta un stream de eventos caído en lugar de enviar la misma tarea otra vez. Para flujos repetidos, inspecciona aciertos de caché y mantén estable el contexto reutilizable. Compara el costo total de todos los intentos con el número de presentaciones que realmente aceptas; un primer borrador barato que necesite varias repeticiones puede costar más en conjunto.
Solución de problemas comunes de API
- Falla de autenticación: verifica que la clave de API esté configurada en el terminal que envía la solicitud y que pertenezca a la cuenta prevista. Inspecciona el error HTTP antes de repetir la llamada.
- curl rechaza una opción, o falta jq: revisa las utilidades instaladas. Estos ejemplos requieren una versión de curl que soporte
--fail-with-bodyy un ejecutable jq funcional en el mismo entorno Bash. - jq no puede extraer un ID: abre el JSON de respuesta guardado. Puede contener un error del API en lugar de un objeto de recurso exitoso. Corrige primero la solicitud en lugar de pasar un ID vacío al siguiente endpoint.
- Un flujo de trabajo con herramienta personalizada deja de progresar: inspecciona eventos de herramientas pendientes. Una razón de parada
requires_actionsignifica que el cliente necesita devolver el resultado de una herramienta o manejar una confirmación antes de que el hilo afectado continúe. - Las diapositivas descargadas contienen afirmaciones no admitidas: compáralas con el resumen o el informe proporcionado. Revisa la tarea con la discrepancia específica e inspecciona el próximo entregable antes de usarlo.
Registra el endpoint, el estado HTTP, el ID de sesión y el evento relevante al diagnosticar un fallo. Mantén las claves de API fuera de los logs de diagnóstico.
Conclusión
Comienza con un flujo de trabajo completo de Kimi Hosted Agents: selecciona un agente, prepara su entorno, crea una sesión, envía una tarea e inspecciona el archivo entregado. Una vez que ese camino funcione, agrega un documento fuente y luego las herramientas de negocio que tu aplicación necesite. Mantén visible el progreso y juzga cada ejecución por la utilidad de su salida, no solo por si la solicitud tuvo éxito.
Preguntas frecuentes
¿Necesito reenviar una tarea de Kimi Hosted Agents después de una desconexión?
No. Un stream de eventos desconectado no requiere un nuevo envío de tarea. Reconéctate con el valor id: del último frame SSE en el header Last-Event-ID para reanudar la lectura. Este valor es un cursor de stream, no el ID JSON del evento. Reconectarte evita enviar accidentalmente el mismo trabajo dos veces.
¿Qué pasa si una salida de Kimi Hosted Agents no aparece en los artifacts?
Un archivo del sandbox puede existir sin estar registrado como artifact. Verifica si el agente completó la presentación y llamó a save_artifact. Si falta el registro, usa los APIs de archivos de sesión para inspeccionar el directorio de salida: GET /v1/sessions/{session_id}/filesystem?prefix=output. El listado cubre un directorio a la vez; actualiza prefix para inspeccionar un subdirectorio. Descarga el archivo elegido con GET /v1/sessions/{session_id}/filesystem/raw?path=output/northstar.pptx, reemplazando la ruta de ejemplo con la ruta exacta devuelta por el listado. Codifica la URL del valor de la query si la ruta contiene espacios u otros caracteres reservados. Incluye los mismos headers de autorización y versión de API que en el tutorial.
¿Actualizar una configuración de Kimi Hosted Agents cambia una sesión activa?
No. Una sesión usa la versión del agente fijada al momento de creación. Actualizar el agente crea una nueva versión para sesiones posteriores, mientras las sesiones existentes mantienen su configuración original. Para probar instrucciones o herramientas revisadas, inicia una nueva sesión y compara su salida con la ejecución anterior.

