Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
Defina o que seus agentes de IA podem fazer. Aplicar políticas em tempo de execução. Mantenha-se no controle em frameworks, plataformas e ambientes de nuvem.
Os agentes de IA estão indo além das conversas. Eles recuperam informações confidenciais, invocam ferramentas, executam transações, interagem com sistemas empresariais e tomam cada vez mais decisões em nome de usuários e organizações.
À medida que os agentes se tornam mais autônomos, surge uma questão fundamental: Como você dá aos agentes a liberdade de agir sem desistir do controle sobre o que eles têm permissão para fazer?
Os prompts do sistema e os filtros tradicionais de segurança de IA fornecem proteções importantes, mas não são suficientes para controlar todas as ações que um agente autônomo pode tomar. Um agente pode gerar texto perfeitamente aceitável ao emitir um reembolso não autorizado, acessar registros restritos ou invocar uma ferramenta em violação da política da empresa.
As empresas precisam de uma maneira de definir limites em torno do comportamento do agente, avaliar ações conforme elas ocorrem e impor políticas consistentes sem codificar regras de negócios em todos os agentes.
Os Controles de Agente são um serviço de política gerenciada que permite que desenvolvedores e organizações definam, gerenciem centralmente e avaliem políticas que regem o comportamento do agente de IA em runtime.
Baseado na ACS (Especificação de Controle de Agente) de software livre e no Agent Hooks, Agent Controls traz a avaliação de política gerenciada para agentes criados em diferentes estruturas, plataformas e nuvens.
Com Agent Controls, você pode:
- Controle o que os agentes fazem, não apenas o que eles dizem. Defina políticas para execução de ferramentas, transações comerciais, acesso a informações confidenciais e conteúdo gerado.
- Vá além dos filtros de segurança tradicionais. Combine regras de negócios determinísticas, classificadores internos de segurança de conteúdo e avaliações baseadas em LLM com suporte para tomar decisões de políticas com reconhecimento de contexto.
- Aplicar políticas em tempo de execução. Avalie as ações e respostas propostas em pontos críticos de intervenção antes de permitir que o agente prossiga.
- Gerenciar e reutilizar políticas centralmente. Defina políticas uma vez, gerencie-as independentemente do código do aplicativo e aplique-as consistentemente em vários agentes e aplicativos.
- Preservar a visibilidade das decisões de política. Receba recibos de avaliação que identificam a política e a versão usadas, para que as equipes de aplicativos possam associar decisões a resultados reais de execução.
Agent Controls separa as decisões de política da execução do agente. O serviço avalia políticas e retorna decisões como allow, denyou transform. O runtime ou o aplicativo do agente permanece responsável por impor essas decisões.
Por que usar controles de agente?
Os agentes não estão mais apenas gerando conteúdo. Eles estão tomando medidas.
As abordagens tradicionais para a segurança da IA se concentram nas entradas e saídas de modelos de IA: detectar conteúdo prejudicial, proteger informações confidenciais ou evitar respostas não seguras.
Mas agentes autônomos introduzem uma nova classe de riscos. Considere um agente de IA responsável por lidar com solicitações de suporte ao cliente. O agente pode pesquisar informações do cliente, processar reembolsos, atualizar detalhes da conta e se comunicar com os clientes.
O agente pode ser instruído a não emitir reembolsos acima de $100. Mas o que acontece quando um cliente o convence a emitir um reembolso de US$ 500?
- Um prompt do sistema pode descrever a restrição, mas não poderá impedir a execução de forma independente se o modelo produzir a chamada de ferramenta proibida.
- Um classificador de segurança de conteúdo pode avaliar se uma resposta contém conteúdo prejudicial ou confidencial, mas não sabe inerentemente se um reembolso está dentro dos limites financeiros da empresa.
- E um fluxo de trabalho de aprovação genérica pode exigir revisão humana para cada reembolso, minando a eficiência e a autonomia que a organização esperava alcançar.
O desafio não é simplesmente tornar os agentes mais seguros. É tornar a autonomia governável.
De fluxos de trabalho rígidos à autonomia controlada
As empresas querem agentes de IA que possam se adaptar, raciocinar e agir de forma independente. Mas eles também precisam de garantias de que os agentes operarão dentro de suas políticas organizacionais.
Historicamente, essa necessidade geralmente significa escolher entre três abordagens:
- Restringir a autonomia. Defina fluxos de trabalho altamente prescritivos e regras determinísticas para todas as ações possíveis.
- Introduza pontos de controle com intervenção humana. Exigir que as pessoas aprovem ações potencialmente conseqüentes, aumentando a sobrecarga operacional.
- Aceite maior incerteza. Dê aos agentes uma autonomia mais ampla, dependendo fortemente de prompts e verificações específicas do aplicativo para evitar comportamentos indesejados.
Nenhuma dessas abordagens aborda totalmente a necessidade de agentes autônomos operando dentro dos limites de negócios aplicáveis.
Os Controles de Agente introduzem outra abordagem: definir os limites centralmente, avaliar o comportamento do agente em runtime e permitir que os agentes operem de forma autônoma dentro desses limites. Em vez de tentar prescrever cada etapa que um agente deve tomar, as organizações podem definir as condições sob as quais uma ação é permitida.
Por exemplo, uma política pode permitir que um agente de suporte emita reembolsos abaixo de US$ 100, negar reembolsos acima desse valor e identificar ações que exigem revisão humana. O agente permanece livre para determinar como concluir uma tarefa, mas o aplicativo impõe a política configurada quando ações relevantes são tentadas. Essa abordagem possibilita introduzir maior autonomia sem tornar todas as decisões de negócios dependentes da disposição do modelo em seguir as instruções.
Criado em uma base aberta: Agent Hooks e ACS
Os desenvolvedores criam agentes de IA usando estruturas, modelos, linguagens de programação e plataformas de nuvem diferentes. As empresas podem operar agentes no Microsoft Foundry ao lado de agentes criados usando outras estruturas ou hospedados em outros ambientes.
Os controles de runtime não devem exigir que todos os agentes sejam reescritos para uma única plataforma ou que cada equipe de desenvolvimento invente um novo mecanismo de imposição de política.
É por isso que Microsoft introduziu dois blocos de construção complementares de software livre.
Ganchos de Agente: Interceptar ações no momento certo
Agent Hooks definem pontos de intervenção padronizados no ciclo de vida de execução do agente.
Esses ganchos dão aos runtimes do agente a oportunidade de pausar a execução e consultar um avaliador de política antes de prosseguir.
Por exemplo, um runtime do agente pode interceptar:
- Entrada recebida: Antes de uma solicitação do usuário entrar no fluxo de execução do agente.
- Interações de modelo: Antes que uma solicitação de modelo seja enviada ou depois que sua resposta for recebida.
- Execução da ferramenta: Antes que uma chamada de ferramenta seja executada ou depois que seu resultado for retornado.
- Saída do agente: Antes que a resposta final seja lançada para o usuário.
- Eventos de ciclo de vida do agente: Quando uma sessão do agente é iniciada ou desligada.
O Agent Hooks fornece o mecanismo de interceptação e imposição. Ele não determina quais regras de negócios ou políticas de segurança devem ser aplicadas. Essa responsabilidade pertence a um avaliador de política.
Especificação de controle do agente (ACS): defina o que é permitido
A ACS (Especificação de Controle de Agente) de software livre fornece um modelo de política comum e um runtime de avaliação para controlar o comportamento do agente.
O ACS permite que os desenvolvedores descrevam políticas independentemente da implementação do agente.
Uma política pode especificar:
- Quais ações de agente ou eventos de ciclo de vida ele rege.
- Qual conteúdo, argumentos de ferramenta ou contexto de runtime devem ser avaliados.
- Quais regras determinísticas ou avaliadores com suporte devem ser aplicadas.
- Qual decisão deve ser retornada quando as condições de política forem atendidas.
Por exemplo, uma política do ACS pode expressar que uma operação de reembolso só é permitida quando o valor solicitado está dentro do limite configurado da organização. Em vez de enterrar essa restrição em um prompt do sistema ou duplicá-la entre wrappers de ferramentas, os desenvolvedores podem expressar o requisito como uma política explícita e executável.
As políticas do ACS podem ser avaliadas usando o runtime de software livre em um aplicativo ou por meio do serviço de controle do agente gerenciado.
Aberto por design. Compatível com ecossistemas de agentes.
Os Ganchos de Agente e o ACS foram projetados para separar o runtime do agente, a avaliação de política e o mecanismo de imposição. Essa separação é fundamental para a governança entre plataformas e a governança de agentes entre nuvens. Os desenvolvedores podem integrar os blocos de construção de software livre com seus hosts de agente escolhidos, mantendo uma abordagem comum para descrever e avaliar políticas.
A arquitetura resultante não exige que o agente subjacente seja executado no Microsoft Foundry ou use um provedor de modelo específico. Os runtimes do agente precisam implementar os pontos de interceptação relevantes, fornecer contexto de execução confiável e impor decisões de política. A base de software livre possibilita essas integrações sem exigir que todas as estruturas de agente adotem um modelo de política completamente diferente.
De blocos de construção de software livre ao controle em escala empresarial
Os blocos de construção de software livre dão aos desenvolvedores a flexibilidade para implementar controles de runtime em seus próprios aplicativos. Mas as grandes organizações enfrentam um desafio adicional. Eles raramente têm apenas um agente. Eles podem ter centenas ou milhares de agentes desenvolvidos por equipes diferentes, usando estruturas diferentes e em execução em vários ambientes.
Sem o gerenciamento centralizado de políticas, cada equipe deve armazenar, configurar, distribuir e atualizar suas políticas de forma independente. Isso cria desafios operacionais:
- Como as equipes de segurança e governança podem estabelecer políticas que se aplicam consistentemente entre aplicativos?
- Como os desenvolvedores podem reutilizar regras organizacionais sem duplicar a lógica de política?
- Como os proprietários de políticas podem atualizar os requisitos sem coordenar lançamentos de aplicações em dezenas de equipes?
- Como as organizações podem entender qual versão da política foi avaliada quando um agente tomou uma ação específica?
- Como eles podem dar suporte a estruturas de agente diferentes sem introduzir sistemas de governança separados para cada uma delas?
É aqui que o Agent Controls estende a base de software livre. Agent Controls fornece gerenciamento centralizado de políticas e avaliação de políticas hospedada baseada no ACS. Os proprietários de políticas podem criar e gerenciar políticas compartilhadas, enquanto os desenvolvedores integram seus aplicativos a uma API de avaliação comum. Em vez de implantar uma cópia independente de cada política em cada aplicativo, as equipes podem fazer referência a políticas gerenciadas centralmente por ID.
Quando um agente precisa avaliar uma ação, seu host envia o contexto de runtime relevante ao Agent Controls. O serviço avalia a política selecionada e retorna uma decisão para o host impor. Isso fornece uma camada de política gerenciada comum para ambientes de agente heterogêneos, sem exigir que o próprio serviço hospede ou execute esses agentes.
Como Agent Controls funciona
Agent Controls seguem um fluxo de controle de runtime simples:
- Definir e publicar políticas. Os proprietários de políticas criam políticas ACS descrevendo comportamentos permitidos e proibidos e, em seguida, publicam as políticas nos Controles do Agente.
- Interceptar uma ação do agente. Um runtime do agente captura uma ação ou conteúdo em um ponto de intervenção relevante, como imediatamente antes de uma chamada de ferramenta.
- Avalie a política aplicável. O runtime chama Agent Controls, fornecendo a ação proposta, o contexto de execução e a política a ser avaliada.
- Retorne uma decisão. Agent Controls avaliam a política, incluindo quaisquer observações configuradas, e retornam um veredito e um recibo de avaliação.
- Aplicar a decisão. O runtime do agente permite, bloqueia ou transforma a operação proposta de acordo com o veredicto retornado.
O Agent Hooks determina quando verificar. O ACS define como as políticas são expressas e avaliadas. Agent Controls fornece gerenciamento centralizado e avaliação hospedada. O runtime do agente impõe a decisão.
Exemplo: um agente de reembolso operando dentro dos limites de negócios
Imagine uma empresa implantando um agente de suporte ao cliente que pode processar reembolsos. A organização define as seguintes políticas:
| Policy | Comportamento desejado |
|---|---|
O valor do reembolso não deve exceder $100 |
Negar solicitações de reembolso acima do limite |
| As informações do cliente só podem ser compartilhadas com destinos aprovados | Negar transferências não autorizadas |
| As respostas não devem expor informações pessoais confidenciais | Avaliar o conteúdo e bloquear ou transformar quando necessário |
| Determinados compromissos do cliente exigem aprovação | Negar a ação imediata e iniciar o processo de revisão do host |
Agora imagine que o agente propõe a seguinte chamada de ferramenta:
{
"tool": "refund_order",
"arguments": {
"order_id": "demo-001",
"amount": 150
}
}
Antes de executar a operação, o runtime do agente intercepta a chamada de ferramenta proposta no pre_tool_call ponto de intervenção. O runtime envia a ação proposta e seu contexto ao Agent Controls. Os Controles do Agente avaliam a política ACS aplicável. A regra determinística verifica o valor do reembolso em relação ao limite permitido pela organização.
Como $150 excede o máximo de $100, a política retorna um deny veredicto. O runtime do agente impõe esse veredicto impedindo a execução da ferramenta de reembolso.
Por outro lado, um reembolso de $75 atenderia à política e devolveria allow. O agente não é necessário para solicitar aprovação humana para cada ação, nem é necessário seguir uma sequência predefinida rígida de etapas. Ele pode operar dentro dos limites estabelecidos pela organização.
Este exemplo ilustra o valor central das políticas de runtime: os agentes podem permanecer autônomos na forma como executam tarefas enquanto são restringidos em quais ações podem ser executadas.
ACS e controles de agente hospedados: qual você deve usar?
O runtime do ACS de código aberto e os Controles de Agente hospedados compartilham a mesma base de política, mas atendem a diferentes necessidades operacionais.
| Capability | ACS de código aberto no processo | Controles do agente hospedado |
|---|---|---|
| Definir políticas usando o ACS | Yes | Yes |
| Avaliar políticas de Rego determinísticas | Yes | Yes |
| Executar a avaliação da política | SDK de código aberto | serviço gerenciado por Microsoft |
| Publicar e atualizar políticas | Arquivos gerenciados pelo aplicativo ou infraestrutura personalizada | Política do ARM compartilhada e recursos de Rego |
| Configurar observações | Anotadores configurados pelo aplicativo | Classificadores de Segurança de Conteúdo com suporte e juízes LLM habilitados |
| Reutilizar políticas entre aplicativos | Por meio da distribuição e integração personalizadas | Por meio de recursos de política gerenciados centralmente |
| Interceptar a execução do agente | Host do agente | Host do agente |
| Aplicar veredictos de política | Host do agente | Host do agente |
Use ACS de código aberto quando quiser incorporar e operar a avaliação de políticas em seu próprio aplicativo ou infraestrutura.
Use hosted Agent Controls quando quiser gerenciar centralmente as políticas e contar com um serviço gerenciado para avaliação de políticas entre agentes e aplicativos.
As duas abordagens são complementares. Uma organização pode usar os blocos de construção de software livre para integração de aplicativos e desenvolvimento local, usando controles de agente hospedados para políticas corporativas compartilhadas.
Conceitos principais
Host do agente
O host é o aplicativo, o runtime do agente ou o gateway que possui a execução. Ele sabe quando uma solicitação de modelo, chamada de ferramenta ou saída está prestes a ocorrer. Ele constrói o contexto, chama controles do agente e decide se a execução pode continuar.
O host deve relatar a ação real e usar os valores avaliados. Avaliar um conjunto de argumentos de ferramenta e encaminhar outro ignora a política.
Ponto de intervenção
Um ponto de intervenção identifica quando uma política se aplica.
| Point | Avaliar antes |
|---|---|
agent_startup |
Iniciando uma sessão |
input |
Aceitando uma entrada externa no agente |
pre_model_call |
Enviando uma solicitação ao modelo |
post_model_call |
Consumindo uma resposta de modelo concluída |
pre_tool_call |
Expedindo uma chamada de ferramenta |
post_tool_call |
Consumindo um resultado de ferramenta concluído |
output |
Liberando a saída final |
agent_shutdown |
Concluindo o desligamento da sessão |
A política acs especifica os pontos de intervenção nos quais suas regras se aplicam. O host do agente chama o Agent Controls nesses pontos para avaliar a ação ou o conteúdo correspondente.
As avaliações de pré-chamada determinam se uma solicitação de modelo ou chamada de ferramenta pode continuar. As avaliações pós-chamada regem o uso de respostas e resultados após a conclusão da operação subjacente.
Manifest e Rego
Uma política Agent Controls consiste em duas partes: um manifesto JSON e um ou mais módulos Rego.
O manifesto seleciona o ponto de ciclo de vida, o valor de tempo de execução e as regras rego em avaliação. Rego expressa a lógica de decisão. Os módulos rego são carregados separadamente e referenciados pela política do ARM.
Por exemplo, um agente de suporte ao cliente propõe uma refund_order chamada de ferramenta com uma ID de pedido e um valor de reembolso de 75. A política de negócios permite reembolsos de até 100.
Para impor esse limite, o manifesto associa o pre_tool_call ponto de intervenção à consulta data.refund_guard.verdictRego. Ele seleciona tool_call.args do payload enviado como alvo da avaliação.
A regra Rego usa o nome da ferramenta para identificar uma solicitação de reembolso. Ele verifica deterministicamente que o valor é numérico, maior que zero e não maior que 100.
snapshot e destino
O snapshot descreve o evento atual do agente em um ponto de intervenção. Para uma chamada de ferramenta proposta, ela inclui o nome e os argumentos da ferramenta, juntamente com os detalhes do agente e da sessão.
O alvo é a parte desse instantâneo que a política está configurada para verificar. No exemplo de reembolso, o manifesto seleciona os argumentos da ferramenta:
Snapshot: proposed tool call
Tool name: refund_order
Arguments: <-- target
order_id: demo-001
amount: 75
Agent and session details
O Rego pode inspecionar todo o snapshot, incluindo os argumentos selecionados. O alvo fornece às políticas uma referência consistente aos dados que estão sendo verificados, independentemente do ponto de intervenção. Ele também identifica os dados que uma transformação permitida pode alterar.
Anotador
Um annotator verifica o conteúdo quanto a uma política. Ele é executado antes de Rego e retorna uma anotação, como uma categoria detectada, um rótulo ou uma pontuação.
Atualmente, os Controles de Agente dão suporte a dois tipos de anotador:
- classificadores do Segurança de Conteúdo de IA do Azure detectam categorias configuradas, como injeção de prompt e violência.
- Os juízes LLM classificam o conteúdo usando critérios personalizados escritos na política.
O manifest especifica qual anotador executar, em qual ponto de intervenção e qual conteúdo ele verifica. Rego usa a anotação retornada como entrada junto com o instantâneo e os targets ao avaliar a política.
Por exemplo, uma política de suporte pode proibir promessas de reembolso em respostas ao cliente. No ponto de output intervenção, um juiz da LLM verifica a resposta proposta e pode rotulá-la commitment. Em seguida, a regra Rego pode usar o rótulo e retornar deny.
Verdito
Um veredicto é o resultado de uma avaliação de política. Ele informa ao host do agente se a ação proposta pode continuar, deve ser bloqueada ou requer uma alteração primeiro.
-
allow: o host pode executar a ação proposta ou liberar o conteúdo conforme enviado. -
deny: o host bloqueia a ação ou retém o conteúdo. -
transform: o host aplica a alteração especificada no veredito ao destino, valida o resultado e prossegue com os dados atualizados.
No exemplo de reembolso, a regra permite um valor válido de 75 e retorna allow. Uma quantidade 150 excede o limite, portanto, a regra retorna deny e o host não emite o reembolso. Uma política diferente pode retornar transform para ocultar um campo em uma resposta antes de ser liberada.
Um veredicto também pode incluir:
- Avisos, que fornecem informações adicionais sem alterar a decisão.
-
Uma solicitação de aprovação, que acompanha uma
denydecisão e inclui detalhes para o processo de revisão do host. A ação permanece bloqueada até que o fluxo de trabalho de aprovação configurado do host a aprove.
Recibo de avaliação
Um recibo de avaliação é um registro retornado com o veredicto. Ele identifica as políticas e versões avaliadas, o ponto de intervenção verificado e uma ID de avaliação. O host usa o recibo para verificar se o resultado corresponde à sua solicitação e à política esperada.
Por exemplo, o recibo de uma checagem de reembolso identifica a versão da política usada para avaliar essa chamada. O host registra a ID de avaliação junto com o resultado real do reembolso, como emitido ou bloqueado. Esse processo permite que os operadores rastreiem a ação do aplicativo de volta à avaliação da política.
Usar Agent Controls com seu aplicativo
Os Controles de Agente fornecem duas superfícies de API complementares:
Plano de controle: gerenciar políticas
Use o plano de controle Azure Resource Manager (ARM) para publicar, atualizar e gerenciar recursos de política do ACS e módulos reutilizáveis do Rego.
Plano de dados: avaliar políticas
Use a Unified Moderate data plane API para avaliar ações e conteúdo em relação a políticas gerenciadas centralmente.
Para o fluxo de avaliação de política autônomo, o aplicativo seleciona uma política usando o policyId parâmetro de consulta e fornece o contexto de execução relevante.
O serviço retorna o veredito de avaliação e o recibo para o aplicativo chamador processar.
O perfil de API com escopo de projeto usa e tem requisitos separados targetResourceId de autorização e recebimento. Não é um seletor intercambiável para o fluxo autônomo policyId .
Para obter exemplos completos, consulte exemplos de código de Agent Controls.
Entender o limite de aplicação
Os Controles do Agente não executam seu agente, suas ferramentas, colocam seu processo em sandbox nem controlam um caminho que ignora o código de interceptação. Ele não infere as permissões de um usuário de um prompt ou torna uma declaração de identidade gerada por modelo confiável.
Mantenha a autorização e os dados comerciais autoritativos em sistemas de aplicativos confiáveis. Use políticas para decidir o que pode prosseguir com base em contextos construídos corretamente e verificar a aplicação no host.
Billing
Durante a visualização pública, você paga apenas por classificador e uso de LLM disparados pela avaliação da política do Agent Controls.
O uso do classificador de Segurança de Conteúdo é cobrado de acordo com os preços de Segurança de Conteúdo. Se sua política invocar um juiz LLM, você também será responsável pelos encargos de uso do modelo associado.