> ## Content Index
> Fetch the complete content index at: https://www.azurebrasil.cloud/llms.txt
> Use this file to discover other available public pages before exploring further.

# Microsoft Foundry Routines: como agendar a execução dos seus agentes
- URL: https://www.azurebrasil.cloud/blog/microsoft-foundry-routines-como-agendar-a-execucao-dos-seus-agentes/
- Published: 2026-07-30T12:09:02.000Z
- Updated: 2026-07-30T12:09:02.000Z
- Description: Aprenda a usar o Microsoft Foundry Routines para executar agentes automaticamente pela interface do Foundry e pela REST API.
- Author: Mateus Nascimento

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:

```text
                                                            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:

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2026/07/image-9.png)

- `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:

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2026/07/image-10.png)

- 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`.

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2026/07/image-11.png)

- 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:

```text
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`.

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2026/07/image-12.png)

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:

```bash
az login

```

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

```bash

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:

```bash
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`:

```bash
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
```

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2026/07/image-14.png)

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:

```bash
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
```

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2026/07/image-15.png)

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.

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2026/07/image-17.png)

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:

```bash
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 '{}'
```

![](https://storage.ghost.io/c/00/52/0052dced-0017-4d07-b190-1f5c48e0ab59/content/images/2026/07/image-16.png)

  
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:

```bash
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.