Microsoft Foundry Routines: como agendar a execução dos seus agentes

Se você já tentou colocar um agente do Microsoft Foundry para executar sozinho todos os dias, provavelmente precisou usar outro serviço para cuidar do agendamento.

O agente era criado no Foundry, o prompt era testado no playground e tudo funcionava bem. Mas, na hora de executar esse agente às 8h da manhã, era comum criar um Logic App com um gatilho de recorrência ou uma Azure Function com Timer Trigger.

Funciona, claro. O problema é que uma automação simples acaba ganhando mais uma peça de infraestrutura para configurar, monitorar e manter.

Apresentado no ciclo de novidades do Microsoft Build 2026, o Routines leva esse agendamento para dentro do próprio projeto do Microsoft Foundry. Com ele, você define quando o agente deve executar, qual prompt será enviado e acompanha o resultado sem precisar criar um serviço separado apenas para disparar a chamada.

O recurso está em public preview.

O que é o Routines?

Uma routine é uma regra de automação associada a um agente.

Ela possui duas partes:

                                                            Trigger
                                                               ↓
                                                            Routine
                                                               ↓
                                                    Agente do Microsoft Foundry

O trigger define quando a rotina começa. E a action informa qual agente será chamado.

Quando o gatilho dispara, o Foundry cria um registro da execução, envia o input para o agente e guarda o resultado. O agente continua usando o mesmo modelo, instruções, ferramentas e identidade que já estavam configurados no projeto.

Atualmente, estão disponíveis três tipos de gatilho:

Recurring schedule: execução recorrente por expressão cron;
One-time schedule: execução única em uma data, horário ou intervalo futuro;
github_issue: execução quando uma issue é aberta ou fechada em um repositório monitorado.

Cada routine aceita somente um trigger e uma action. Para executar o mesmo agente em dois horários diferentes, por exemplo, você precisa criar duas routines.

No momento, o Routines está liberado para projetos criados nestas regiões:

East US
East US 2
West US
West US 2
West Central US
North Central US
Sweden Central
Japan East

Como estamos falando de um recurso em preview, essa lista pode mudar. Consulte a documentação oficial antes de criar um ambiente especificamente para usar o Routines.

Antes de começar

Para acompanhar o exemplo, você precisa ter:

Um projeto ativo no Microsoft Foundry;
Um agente já criado e implantado;
A função Foundry User (Azure Ai User) ou superior no projeto;
O projeto em uma das regiões suportadas.

Neste artigo, vamos criar uma rotina que executa um agente que consulta os tickets em aberto de segunda a sexta-feira às 8h.

Criando uma routine pela interface do Foundry

Abra o Microsoft Foundry e entre no projeto onde o agente está implantado.

Depois, siga estes passos:

Antes de tudo verifique se está no New Foundry.
Clique em Agents e depois em Routines e + New routine.
Informe um nome, como resumo-matinal.

Escolha o agente que será executado e o prompt enviado em cada execução.
Em Trigger, selecione Recurring schedule.
Escolha a frequência e o horário.
Clique em Create & start.

Um exemplo de prompt seria:

Consulte os tickets criados ou atualizados nas últimas 24 horas.

Organize o resultado com:

quantidade total de tickets;
tickets novos;
tickets ainda abertos;
chamados com prioridade alta ou crítica;
tickets próximos de ultrapassar o SLA;

Ao final, apresente um resumo curto com os pontos que precisam de atenção. 
Caso não existam tickets críticos ou próximos do vencimento do SLA, 
informe isso claramente.

Para uma execução única, selecione One-time schedule e informe a data e o horário em Run at.

Há um detalhe importante: o horário escolhido na interface é interpretado usando o fuso local do navegador.

Se você quiser fixar a execução em uma zona específica, independentemente de quem estiver acessando o portal, use a REST API e informe o campo time_zone.

Testando e acompanhando a execução

Depois de criar a rotina, abra sua página e clique em Test run.

O Foundry coloca a execução na fila sem esperar pelo próximo horário programado. O status pode passar de Queued para Completed ou Failed.

Na mesma página, você encontra o histórico das execuções, com informações como horário, duração, estado e identificador da resposta.

Também é possível pausar e retomar a rotina sem excluí-la.

Criando a mesma routine pela REST API

Os exemplos desta seção utilizam Bash. No Windows, você pode executá-los pelo Git Bash dentro do Visual Studio Code ou pelo WSL.

A API também pode ser chamada por PowerShell, Postman, .NET ou qualquer outro cliente HTTP. O endpoint e o JSON permanecem os mesmos; apenas a sintaxe usada para enviar a requisição muda.

Vamos criar a mesma rotina do exemplo anterior, mas agora fixando o fuso horário como America/Recife.

Preparando o acesso

Primeiro, faça login na Azure CLI:

az login

Depois, configure o endpoint do projeto e o nome do agente:


PROJECT_ENDPOINT="https://<conta>.services.ai.azure.com/api/projects/<projeto>"
AGENT_NAME="<nome-do-agente>"
ROUTINE_NAME="resumo-diario-tickets"

O PROJECT_ENDPOINT é o endereço do projeto no Microsoft Foundry. Ele não é o endpoint do modelo.

Você pode encontrá-lo nas informações do projeto no portal.

Agora obtenha um token de acesso do Microsoft Entra ID:

TOKEN=$(az account get-access-token \
  --resource https://ai.azure.com \
  --query accessToken \
  -o tsv)

Esse token será enviado no cabeçalho Authorization de cada chamada.

Criando a routine

Para evitar problemas com aspas e caracteres especiais no terminal, vamos colocar a configuração em um arquivo JSON.

Crie o arquivo routine.json:

cat > routine.json <<EOF
{
  "description": "Consulta os tickets e gera um resumo diario.",
  "enabled": true,
  "triggers": {
    "manha-dias-uteis": {
      "type": "schedule",
      "cron_expression": "0 8 * * 1-5",
      "time_zone": "America/Recife"
    }
  },
  "action": {
    "type": "invoke_agent_responses_api",
    "agent_name": "$AGENT_NAME",
    "input": "Consulte os tickets criados ou atualizados nas ultimas 24 horas. Apresente a quantidade total, os tickets novos, os chamados de prioridade alta ou critica, os tickets proximos de ultrapassar o SLA e os pontos que precisam de atencao. Nao invente informacoes e use somente os dados retornados pela ferramenta de consulta de tickets."
  }
}
EOF

Confira o conteúdo antes de enviá-lo:

cat routine.json

A expressão cron usada no exemplo significa “às 8h, de segunda a sexta-feira”:

0 8 * * 1-5

O campo time_zone fixa o horário em America/Recife, sem depender do fuso configurado no navegador.

Os campos principais são:

enabled: cria a routine ativa;
triggers: contém a configuração do gatilho;
cron_expression: define os dias e o horário;
time_zone: fixa o fuso;
action: informa como o agente será chamado;
agent_name: aponta para o agente já implantado;
input: contém o prompt enviado em cada execução.

Enviando a configuração

Crie a routine com a chamada abaixo:

curl -i -sS -X PUT \
  "$PROJECT_ENDPOINT/routines/$ROUTINE_NAME?api-version=v1" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Foundry-Features: Routines=V1Preview" \
  --data-binary @routine.json

Uma criação bem-sucedida retorna HTTP 200 ou 201 com o objeto da routine. Depois disso, ela também passa a aparecer na interface do Microsoft Foundry.

O mesmo endpoint funciona como create-or-update. Caso você envie novamente uma requisição PUT usando o mesmo nome, a definição armazenada será substituída pelo novo conteúdo.

Executando um teste pela REST API

Não é necessário esperar até o próximo horário programado.

Para executar a routine imediatamente usando o prompt já configurado, envie:

curl -i -sS -X POST \
  "$PROJECT_ENDPOINT/routines/$ROUTINE_NAME:dispatch_async?api-version=v1" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Foundry-Features: Routines=V1Preview" \
  -d '{}'

O retorno terá uma estrutura semelhante a esta:

{
  "dispatch_id": "disp-abc123",
  "action_correlation_id": "resp-xyz456",
  "task_id": "task-def789"
}

O dispatch_id identifica o disparo e ajuda a localizar a execução no histórico.

Um ponto que costuma causar confusão: essa resposta confirma que o trabalho foi colocado na fila. Ela não significa que o agente já terminou o processamento.

Para confirmar a conclusão, é necessário verificar o estado da execução.

Consultando o histórico

Use a chamada abaixo para consultar as execuções da routine:

curl -i -sS \
  "$PROJECT_ENDPOINT/routines/$ROUTINE_NAME/runs?api-version=v1" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/json" \
  -H "Foundry-Features: Routines=V1Preview"

O retorno mostra as tentativas registradas, com informações como estado, horário de início, horário de término e detalhes de erro quando a execução falha.

Você também pode consultar essas informações pela interface do Foundry. A rotina criada pela API aparece no portal junto com as demais, permitindo a verificar falhas, excluir e pausar o agendamento.

Com esses três passos, criação, teste e consulta, já temos o fluxo principal da REST API.

Routines substitui o Logic Apps?

Depende do fluxo.

Para um cenário direto, como “execute este agente todos os dias às 8h”, o Routines reduz bastante o trabalho.

O agendamento, a chamada e o histórico ficam no mesmo projeto:

Logic Apps e Azure Functions continuam sendo escolhas melhores quando o processo possui:

Várias etapas;
Condições e ramificações;
Aprovação humana;
Integração com diferentes sistemas;

O Routines não é um orquestrador completo.

Ele foi criado para responder a uma pergunta mais específica: quando este agente deve executar?

Para processos com decisões, múltiplos agentes, aprovações ou estados mais complexos, uma solução de workflow ou outra camada de orquestração continua sendo mais adequada.

Mesmo com as limitações do preview, é um recurso que vale conhecer antes de criar mais um Logic App apenas para chamar um agente em determinado horário.

As informações deste artigo foram verificadas em julho de 2026. Como o Routines está em public preview, regiões, campos da API e opções da interface podem mudar.