TL;DR
Kimi Hosted Agents executa tarefas de IA em múltiplas etapas com sessões persistentes, execução de ferramentas e sandboxes em nuvem. Este guia leva você de uma chave de API da Kimi a uma apresentação de três slides para download usando Bash, curl e jq. Primeiro, conclua uma tarefa com um prompt autocontido. Depois, adicione um documento enviado, conecte ferramentas de negócios e trate as falhas que importam em uma aplicação em produção.
Principais pontos
- Kimi Hosted Agents conecta uma definição de agente, um ambiente de execução e uma sessão. Mantenha os respectivos IDs disponíveis ao longo do fluxo.
- Comece com um resultado pequeno e verificável. O primeiro exemplo gera uma apresentação com dados fictícios e um cálculo que você pode conferir.
- Use o fluxo de eventos para acompanhar a execução e depois inspecione o arquivo entregue. Um HTTP 200 por si só não comprova sucesso da tarefa.
- Estenda o exemplo funcional com arquivos de entrada, ferramentas personalizadas ou serviços MCP. Cada integração tem seus próprios requisitos de execução e credenciais.
- Orce juntos a inferência, o runtime do sandbox e o uso de plugins, incluindo novas execuções necessárias para obter um resultado aceitável.
O que é Kimi Hosted Agents?
A Moonshot AI anunciou o Kimi Hosted Agents em 5 de novembro de 2026, posicionando-o como um serviço para empresas e desenvolvedores que constroem agentes de longa duração.
O produto adota uma abordagem de Harness as a Service. Um harness é o software em torno de um modelo que gerencia o progresso do trabalho: mantém estado, invoca ferramentas, gerencia a execução e se recupera de interrupções.
Considere um fluxo semanal de pesquisa. Gerar texto é apenas uma etapa. O aplicativo pode também precisar buscar fontes, processar arquivos, criar gráficos, salvar uma apresentação e preservar estado suficiente para continuar após uma desconexão.
Hosted Agents fornece essa camada operacional. Sua equipe ainda define a tarefa de negócio, seleciona integrações e decide o que constitui um resultado aceitável.
A arquitetura oficial da Kimi mostra o aplicativo, os serviços de plataforma e o núcleo de execução usados pelo runtime hospedado.
Capacidades centrais para sua primeira integração
- Sessões persistentes mantêm juntos entradas, eventos de execução e saídas de uma tarefa.
- Sandboxes em nuvem fornecem as ferramentas necessárias para processar arquivos e criar entregáveis.
- Skills e plugins empacotam capacidades reutilizáveis; ferramentas personalizadas e serviços MCP conectam seus próprios sistemas.
Seu primeiro checkpoint é uma apresentação que você pode abrir e inspecionar. Especificações detalhadas do runtime tornam-se úteis quando você adiciona dependências ou move um fluxo existente para o sandbox; a referência do sandbox documenta o ambiente disponível.
O que você precisa antes de chamar a API do Kimi Hosted Agents?
- Uma conta na plataforma Kimi com acesso ao Hosted Agents e uma chave de API.
- Bash, curl e jq no macOS, Linux ou Windows com WSL.
- Dois terminais: Terminal A envia requisições; Terminal B acompanha eventos de execução.
- Um visualizador de apresentações para abrir o PPTX gerado.
Crie uma conta na plataforma Kimi e uma chave de API na área de gerenciamento de API do console. Use um terminal Bash, chamado Terminal A, para os comandos de configuração e de tarefa. Mantenha-o aberto para que etapas posteriores reutilizem suas variáveis. Instale curl e jq antes de continuar. Os exemplos usam a versão beta da 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"
Como executar sua primeira tarefa no Kimi Hosted Agents
O fluxo segue o quickstart da API REST da Kimi. Você usará o assistente oficial de PPT para transformar um breve resumo de negócios fictício em uma apresentação. Todos os dados de entrada são incluídos na requisição; portanto, a primeira execução não requer upload de arquivo ou conexão a dados privados.
Execute cada bloco em ordem e verifique sua saída antes de continuar. Comandos unidos por && interrompem o bloco quando uma requisição ou validação falha. Resolva o erro informado antes de ir para a próxima etapa; mantenha os mesmos IDs de ambiente e sessão ao refazer uma configuração existente.
Etapa 1: Selecione o assistente oficial de PPT
Busque os agentes disponíveis e inspecione seus nomes e definições. Quando solicitado, cole o ID do assistente oficial de PPT configurado com skills de PPT. O comando final verifica se sua seleção existe na lista retornada e imprime sua definição.
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
O comando final deve imprimir a definição do agente selecionado. Se o assistente não estiver disponível no seu projeto, use a configuração oficial do agente de PPT para preparar um agente equivalente antes de prosseguir.
Etapa 2: Crie um ambiente em nuvem
Um Ambiente é uma configuração reutilizável do seu setup de execução, incluindo pacotes instalados, acesso à rede e comandos de inicialização. Reusá-lo dá às sessões subsequentes a mesma configuração; cada sessão em nuvem ainda recebe seu próprio sandbox e workspace. Consulte o guia de ambientes para opções de configuração.
Crie o ambiente uma vez e mantenha seu ID. Imagens em nuvem são construídas de forma assíncrona; aguarde até o status de build ficar ready antes de criar uma sessão. Se a API informar que não está pronto, aguarde e tente novamente com o mesmo ENVIRONMENT_ID. Criar outro ambiente não finaliza o primeiro 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"
Etapa 3: Crie uma sessão
Uma Sessão fixa a versão do Agente e uma versão disponível do Ambiente quando é criada. A requisição abaixo fornece seus IDs; a plataforma seleciona e congela as versões. Você também pode definir agent_version para escolher uma versão exata do Agente. Atualizar o Agente ou Ambiente depois não atualiza uma sessão existente, e uma sessão não pode trocar seu environment_id. Crie uma nova sessão para usar configurações revisadas. Essas regras estão documentadas na criação de sessões.
Guarde o ID de sessão retornado tanto para o fluxo de eventos quanto para as requisições de tarefa. Uma nova sessão começa em idle; enviar user.message inicia a tarefa.
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"
Etapa 4: Acompanhe a execução em um segundo terminal
Abra o Terminal B. Insira a mesma chave de API e depois cole o ID da sessão impresso no Terminal A. O fluxo de eventos SSE exibe atualizações de execução enquanto o Terminal A envia a tarefa. Mantenha este terminal conectado até você inspecionar o 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"
Etapa 5: Envie uma tarefa autocontida
Volte ao Terminal A e envie um evento user.message. O exemplo usa números fictícios e pede um entregável específico. O agente deve usar os fatos fornecidos, sem buscar dados de negócios de suporte.
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
Etapa 6: Baixe e inspecione a apresentação
Observe no Terminal B os eventos session.status. Quando a sessão voltar a idle, inspecione seu motivo de parada: end_turn indica que o turno terminou, enquanto requires_action significa que seu cliente deve fornecer o resultado de uma ferramenta ou lidar com uma confirmação. Verifique também eventos session.error. Depois que o turno terminar sem erro pendente, liste os artefatos e selecione o PPTX gerado.
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'
Abra northstar.pptx. Um resultado bem-sucedido tem três slides, identifica os dados como fictícios e calcula a atividade semanal como 90 ÷ 120 = 75%. Isso dá a você uma verificação concreta de entrega de arquivo e precisão de conteúdo antes de conectar dados reais de negócios.
Como enviar e anexar arquivos a uma sessão do Kimi Hosted Agents?
Depois que a primeira apresentação funcionar, coloque um report.pdf de exemplo no diretório de trabalho do Terminal A. A API de arquivos separa o upload de um arquivo do anexo a uma sessão. Execute este bloco com o ID da sessão existente após a primeira tarefa ter terminado.
Use purpose=file-extract para extrair texto do PDF. A API de arquivos permite até 100 MiB por arquivo e, por padrão, 10 GiB de armazenamento por organização. Arquivos enviados não podem ser atualizados in-place; envie um arquivo revisado e associe seu novo ID. Remova arquivos não usados quando precisar liberar espaço.
Com kimi-api-version: 2026-09-01-beta, verifique extract_status na resposta de upload. Este exemplo prossegue somente quando estiver ready. Se estiver error, inspecione o formato e conteúdo do PDF e, em seguida, envie um arquivo corrigido. A API pode anexar uma extração com falha como arquivo bruto, mas isso não fornece o texto extraído que este tutorial espera. Um status ausente ou inesperado também interrompe o bloco; inspecione 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
Anexar o arquivo não envia uma nova tarefa. Mantenha o Terminal B conectado e envie um follow-up que cite o documento e o resultado desejado.
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 esta tarefa terminar, repita a etapa de listagem de artefatos e selecione o novo PPTX. Compare suas afirmações com o PDF, especialmente números, datas e ações propostas.
Como conectar ferramentas ao Kimi Hosted Agents?
Ferramentas personalizadas executadas pelo seu aplicativo
Para uma ação de negócios como consultar o status de entrega de um projeto, use uma ferramenta personalizada implementada pelo seu aplicativo. Declarar a ferramenta a torna disponível para o agente; seu código ainda executa a operação.
- Declare uma entrada
customno arraytoolsdo agente com nome, descrição einput_schemaem formato de objeto. - Trate
agent.custom_tool_usedo fluxo de eventos e valide os argumentos fornecidos antes de executar sua função. - Publique um evento
user.custom_tool_resultna sessão, usando oidJSON do evento de chamada comodata.event_id.
Comece com uma consulta somente leitura. Mantenha autorização e proteção contra ações duplicadas no aplicativo quando uma integração puder modificar registros de negócios.
Serviços MCP e fluxos maiores
Para um serviço MCP remoto, declare sua conexão em mcp_servers. Armazene credenciais de acesso em um cofre e associe esse cofre ao criar a sessão. A plataforma descobre e chama as ferramentas do serviço; a definição do servidor deve conter detalhes de conexão, não segredos.
Orquestração multiagente opcional
A plataforma suporta delegação de coordenador para filhos. Um coordenador pode atribuir tarefas delimitadas a threads filhos e combinar seus resultados.
Sua configuração de delegação aceita de 1 a 20 entradas de agentes. Este é um limite de configuração, não evidência de 20 trabalhadores simultâneos ou de uma melhoria de velocidade de 20×. Threads filhos não podem criar outra camada de threads filhos.
Um desenho útil pode separar coleta de fontes, análise quantitativa e revisão editorial. Uma tarefa curta de sumarização geralmente é melhor tratada por um único agente.
Como implantar uma integração com Kimi Hosted Agents?
Coloque as chamadas da API Kimi por trás do backend do seu aplicativo. O navegador pode enviar uma tarefa e exibir o progresso por meio de seus próprios endpoints, enquanto o backend mantém a chave de API e mapeia cada usuário às sessões que ele pode acessar. Armazene o ID da sessão com a solicitação de negócio para que um recarregamento de página possa reabrir a mesma tarefa.
Execução hospedada vs. auto-hospedada
Use um ambiente em nuvem para o fluxo de PPT deste guia: ele suporta save_artifact e o fluxo de arquivos da sessão. Escolha um ambiente auto-hospedado quando a execução no sandbox precisar ocorrer em um host gerenciado pela sua organização. A Kimi ainda executa a inferência de modelo, orquestração e gerenciamento de sessão; entradas e resultados de ferramentas passam por sua plataforma. Este é um modelo híbrido de execução.
- Ambientes auto-hospedados exigem verificação corporativa. Você opera o host Worker, instala suas dependências e gerencia isolamento e credenciais. O Worker precisa de acesso HTTPS de saída à plataforma.
- O modo auto-hospedado atualmente não possui
save_artifact, IPython e ferramentas de busca de imagens. Arquivos enviados, skills e memória não são montados no Worker, e seus arquivos de saída não aparecem na lista de arquivos da sessão. Planeje como fornecer entradas e recuperar saídas antes de mover este tutorial para esse modo.
Para uma primeira integração, comece na nuvem. Considere o auto-hospedado quando o controle sobre o host de execução justificar a configuração adicional e as mudanças na entrega de arquivos.
Escolhendo quem opera o runtime
Use Hosted Agents quando você quiser que a plataforma gerencie a execução da sessão. Se sua equipe precisa construir e operar seu próprio loop de agente, a CometAPI fornece acesso unificado a modelos para essa pilha personalizada. Os exemplos de Hosted Agents neste guia usam os próprios endpoints e credenciais da Kimi.
Preços e otimização de custos do Kimi Hosted Agents
Kimi Hosted Agents cobra por tokens de modelo, runtime do sandbox em nuvem e chamadas de plugins pagos. A tabela abaixo mostra como essas cobranças afetam um fluxo de trabalho de apresentação. Preços em yuan chinês (CNY), conferidos em 10 de novembro de 2026 conforme preços do Hosted Agents e preços de inferência de modelo. Um milhão de tokens equivale a 1 MTok.
| Componente de custo | Unidade de cobrança | Tarifa e o que significa para sua tarefa |
|---|---|---|
| Inferência de modelo | Por 1 MTok | Para kimi-k3.1-pro: entrada base ¥13, saída ¥68, cache hits ¥1.30, gravações de cache de 5 minutos ¥13 e gravações de 1 hora ¥26. Aplique a tarifa para cada categoria de uso em todas as chamadas de modelo. |
| Sandbox em nuvem | Runtime; cobrado por segundo | ¥0.072/hora para um sandbox com 1 CPU e 1 GB de memória. Dez minutos custam ¥0.012. |
| Plugins | Por chamada faturável | Exemplos: busca na web ¥0.03/chamada; busca de imagens ¥0.045/chamada. Outros plugins têm suas próprias tarifas. Multiplique as chamadas de cada plugin por seu preço listado. |
| Custo total da tarefa | Por tarefa concluída | Some cobranças de modelo, sandbox e plugins. O exemplo trabalhado abaixo totaliza ¥0.544 sem plugins pagos, ou ¥0.724 com três buscas na web e duas buscas de imagens no mesmo uso estimado de modelo e runtime. |
A tarifa do modelo é um exemplo de orçamento para kimi-k3.1-pro, não uma afirmação de que todo Agente oficial de PPT usa esse modelo. Verifique a definição de modelo do Agente selecionado antes de aplicar essas tarifas. Tarifas para outros modelos e variantes de alta velocidade diferem.
Como contar tokens de entrada e saída
Um Agente pode chamar seu modelo várias vezes ao criar uma apresentação. Some o uso faturado de todas as chamadas, incluindo turnos subsequentes e revisões. A entrada pode incluir o prompt, texto extraído do PDF, resultados de ferramentas e contexto da conversa; a saída faturada não se limita às palavras visíveis nos slides.
Para cache K3, separe entrada não cacheada, gravações de cache e cache hits. São categorias distintas de entrada: não cobre a entrada total inteira à tarifa base e depois some cobranças de cache para os mesmos tokens. Use a tarifa aplicável de gravação de 5 minutos ou 1 hora. O guia de faturamento de cache explica como reconciliar essas categorias com o uso reportado.
Exemplo prático: uma apresentação de três slides
Suponha que seu Agente use kimi-k3.1-pro e uma execução completa de três slides consuma 20.000 tokens de entrada, 4.000 tokens de saída faturados e 10 minutos de runtime em nuvem faturável. Assuma sem cache hits, sem gravações de cache de 1 hora e sem plugins pagos. Toda a entrada é não cacheada ou gravada no cache padrão de 5 minutos, ambos a ¥13/MTok. Essas são quantidades estimadas para planejamento, não medições do tutorial Northstar.
| Cobrança | Cálculo | Custo estimado |
|---|---|---|
| Entrada do modelo | 20.000 ÷ 1.000.000 × ¥13 | ¥0.260 |
| Saída do modelo | 4.000 ÷ 1.000.000 × ¥68 | ¥0.272 |
| Sandbox em nuvem | 10 ÷ 60 × ¥0.072 | ¥0.012 |
| Plugins pagos | 0 chamadas faturáveis | ¥0.000 |
| Total | ¥0.260 + ¥0.272 + ¥0.012 | ¥0.544 (cerca de ¥0.54) |
O tutorial de fatos fornecidos pede ao Agente para não navegar na web. Se depois você o expandir para uma apresentação de pesquisa com três buscas na web e duas buscas de imagens, a cobrança de plugin seria 3 × ¥0.03 + 2 × ¥0.045 = ¥0.180. Mantendo constantes as demais quantidades, resulta em ¥0.544 + ¥0.180 = ¥0.724. Pesquisas podem também aumentar tokens do modelo e runtime, então use as quantidades medidas para a fatura final.
O que muda ao usar vários agentes?
A delegação pode acrescentar chamadas de modelo, contexto repetido, chamadas de ferramentas e trabalho de revisão. O fluxo multiagente da Kimi coloca o coordenador e os threads filhos em uma única sessão. A contagem de threads filhos, por si só, não é um multiplicador para a cobrança do sandbox. Some o uso de modelo e plugins em todos os threads e use o runtime faturável real da sessão. Execução mais longa ou sessões em nuvem independentes adicionais podem aumentar o custo do sandbox. O FAQ explica que o tempo do sandbox para de acumular quando todos os threads terminam e a sessão fica idle.
Reduza o custo por apresentação utilizável
Comece com um Agente e um entregável pequeno. Forneça as passagens de fonte relevantes, limite a contagem de slides e habilite buscas pagas apenas quando a tarefa precisar delas. Reconecte um fluxo de eventos interrompido em vez de enviar a mesma tarefa novamente. Para fluxos repetidos, inspecione cache hits e mantenha estável o contexto reutilizável. Compare o custo total de todas as tentativas com o número de apresentações que você de fato aceita; um rascunho barato que requer várias reexecuções pode custar mais no geral.
Solução de problemas comuns da API
- Falha de autenticação: verifique se a chave de API está definida no terminal que envia a requisição e pertence à conta pretendida. Inspecione o erro HTTP antes de repetir a chamada.
- curl rejeita uma opção, ou falta jq: verifique os utilitários instalados. Esses exemplos exigem uma versão do curl que suporte
--fail-with-bodye um executável jq funcional no mesmo ambiente Bash. - jq não consegue extrair um ID: abra o JSON de resposta salvo. Ele pode conter um erro da API em vez de um objeto de recurso bem-sucedido. Corrija a requisição primeiro, em vez de passar um ID vazio para o próximo endpoint.
- Um fluxo com ferramenta personalizada parou de progredir: inspecione eventos de ferramenta pendentes. Um motivo de parada
requires_actionsignifica que o cliente precisa retornar o resultado de uma ferramenta ou lidar com uma confirmação antes que o thread afetado continue. - Os slides baixados contêm afirmações sem suporte: compare com o resumo ou relatório fornecido. Revise a tarefa com a discrepância específica e inspecione o próximo entregável antes de usá-lo.
Registre o endpoint, o status HTTP, o ID da sessão e o evento relevante ao diagnosticar uma falha. Mantenha chaves de API fora de logs de diagnóstico.
Conclusão
Comece com um fluxo completo do Kimi Hosted Agents: selecione um agente, prepare seu ambiente, crie uma sessão, envie uma tarefa e inspecione o arquivo entregue. Depois que esse caminho funcionar, adicione um documento de origem e, em seguida, as ferramentas de negócios de que seu aplicativo precisa. Mantenha o progresso visível e julgue cada execução pela utilidade de sua saída, não apenas se a requisição teve sucesso.
FAQ
Preciso reenviar uma tarefa do Kimi Hosted Agents após uma desconexão?
Não. Um fluxo de eventos desconectado não exige um novo envio da tarefa. Reconecte-se com o valor id: do último quadro SSE no cabeçalho Last-Event-ID para retomar a leitura. Esse valor é um cursor de fluxo, não o ID JSON do objeto de evento. Reconectar evita enviar o mesmo trabalho duas vezes por engano.
E se uma saída do Kimi Hosted Agents estiver ausente de artifacts?
Um arquivo do sandbox pode existir sem estar registrado como artifact. Verifique se o agente concluiu a apresentação e chamou save_artifact. Se o registro estiver ausente, use as APIs de arquivos da sessão para inspecionar o diretório de saída: GET /v1/sessions/{session_id}/filesystem?prefix=output. A listagem cobre um diretório por vez; atualize prefix para inspecionar um subdiretório. Baixe o arquivo escolhido com GET /v1/sessions/{session_id}/filesystem/raw?path=output/northstar.pptx, substituindo o caminho de exemplo pelo caminho exato retornado na listagem. Codifique o valor da query em URL se o caminho contiver espaços ou outros caracteres reservados. Inclua os mesmos cabeçalhos de autorização e versão de API do tutorial.
Atualizar uma configuração do Kimi Hosted Agents altera uma sessão ativa?
Não. Uma sessão usa a versão do agente fixada na criação. Atualizar o agente cria uma nova versão para sessões subsequentes, enquanto sessões existentes mantêm sua configuração original. Para testar instruções ou ferramentas revisadas, inicie uma nova sessão e compare sua saída com a execução anterior.

