Agentes de IA não estão prontos para produção - e controle de acesso pode ser a razão

-Daniel Bass

Aumentar o desempenho da aplicação através do uso de agentes de IA está se tornando uma prática muito comum - seja devido ao hype em toda a indústria ou casos de uso úteis reais.

These AI agents, however, often require access to highly sensitive data, introducing significant security risks. Without standardized access control solutions, development teams often build security measures from scratch—leading to cases where AI assistants expose sensitive patient information and several AI agents being compromised through sophisticated prompt injection attacks.

Proteger os agentes de IA neste contexto está se tornando tão importante quanto as capacidades dos próprios agentes de IA - se não mais.

To address this problem, we at Permit.io have been working for a while on a structured security approach I wish to introduce to you today:

The Four-Perimeter Framework.

This method provides a comprehensive strategy for protecting AI agents by implementing fine-grained access control, ensuring compliance, and mitigating potential attack vectors. Before I go into the solution, let’s talk more about the problem space.

O problema: riscos de segurança de IA em domínios sensíveis

Traditional application security measures and access control mechanisms fall short when it comes to handling AI agents. While conventional access control systems like role-based access control (RBAC) excel at managing static permissions, they struggle with the dynamic nature of AI responses. Unlike traditional applications where inputs map to predictable outputs and access patterns are well-defined, AI generates unique responses for each query. This means the access control and input validation techniques we’re used to can’t anticipate all possible outputs.

The way AI systems access data also doesn’t fit security standards. To provide accurate and helpful responses, AI agents need broad access to various data sources and knowledge bases. Classic RBAC proves too rigid for this need - you can’t simply assign static permissions when the data requirements change based on context. This calls for a more sophisticated, attribute-based approach that can make dynamic access decisions.

A solução vem na forma de uma estrutura de segurança abrangente construída em torno de quatro perímetros essenciais -

A Solução: O Quadro dos Quatro Perímetros

Como os aplicativos de IA diferem do software padrão em como eles processam entradas, recuperam dados, executam ações e geram saídas, eles também introduzem riscos de segurança únicos.Para enfrentar esses desafios, precisamos de uma abordagem de segurança estruturada que aplique controle de acesso em todas as fases da interação de IA. E isso é exatamente o que eu quero mostrar aqui:

The Four-Perimeter Framework is designed to enforce identity-aware, fine-grained authorization throughout the AI lifecycle. It introduces security boundaries that govern what data AI models can access, what operations they can perform, and how their responses are validated.

O quadro é composto por quatro partes:

1. Prompt Filtering – Garantir que apenas entradas seguras validadas alcancem modelos de IA.
2. RAG Data Protection – Controlar o acesso da IA a fontes externas de conhecimento.
3. Secure External Access – Definir permissões de agente de IA quando interage com ferramentas externas.
4. Response Enforcement – Aplicar verificações de conformidade e filtrar saídas geradas por IA.

Aplicando os princípios de controle de acesso de grãos finos (FGA) nesses perímetros, os agentes de IA permanecem seguros, audíveis e conformes - sem sacrificar sua flexibilidade e funcionalidade.

Onde o FGA entra?

Como mencionado anteriormente, os métodos tradicionais de controle de acesso, como o RBAC, não conseguem lidar com o comportamento dinâmico e contextualmente dependente da IA. É aqui que entra em jogo a autorização de grãos finos (FGA), especificamente através do controle de acesso baseado em atributos (ABAC) e do controle de acesso baseado em relacionamento (ReBAC):

• ABAC para Prompt Filtering Modelos de IA processam entradas não estruturadas, dificultando a aplicação de regras tradicionais de segurança.Os modelos de IA processam entradas não estruturadas, dificultando a aplicação de regras de segurança tradicionais.A ABAC resolve isso extraindo atributos estruturados de prompts de IA e usando-os em decisões de acesso baseadas em políticas.ABAC para filtragem prompt

  
  

  • ReBAC para proteção de dados RAG A geração aumentada de recuperação (RAG) permite que modelos de IA extraam informações de bancos de dados vetoriais.ReBAC fornece uma maneira natural de reforçar a segurança nesta configuração, definindo relações entre usuários, fontes de dados e agentes de IA. Em vez de atribuir permissões estáticas, o ReBAC concede ou nega o acesso dinamicamente com base em como os objetos de dados se relacionam uns com os outros – permitindo permissões de recuperação conscientes do contexto.
• ReBAC para proteção de dados RAG A geração aumentada por recuperação (RAG) permite que modelos de IA extraam informações de bancos de dados vetoriais.ReBAC fornece uma maneira natural de fazer valer a segurança nesta configuração, definindo relações entre usuários, fontes de dados e agentes de IA. Em vez de atribuir permissões estáticas, o ReBAC dinamicamente concede ou nega acesso com base em como os objetos de dados se relacionam uns com os outros – permitindo permissões de recuperação conscientes do contexto.
ReBAC para proteção de dados RAG




Ao combinar ABAC e ReBAC, as aplicações de IA obtêm mecanismos de controle de acesso flexíveis e orientados por políticas que se adaptam a diferentes fluxos de trabalho de IA sem exigir intervenção manual.




O que é uma implementação passo a passo?

Let's walk through a practical implementation to see the Four-Perimeter Framework in action. This example secures an AI agent by validating prompts, enforcing data protection, restricting external access, and moderating responses—leveraging Permit.io AI Access Control integrations at each step.

Quadro de Quatro Perímetros em Açãovalidar prompts, fazer cumprir a proteção de dados, restringir o acesso externo e moderar respostasPermit.io AI Access ControlPermit.io

1. Implementação do filtro de prompt

1 Implementar filtragem de prompt

O primeiro perímetro de segurança centra-se na validação e sanitização das entradas de IA antes que elas cheguem ao modelo.




• Os controles de autorização são incorporados no pipeline de validação instantânea, impedindo que dados não autorizados influenciem as saídas de IA.
• Os controles de acesso baseados em papéis, atributos e relações são aplicados, garantindo que apenas parâmetros aprovados passem para a IA.
• Todas as violações de políticas são logadas e bloqueadas em tempo real, preservando um rastro auditável de decisões de acesso.
Os controles de autorização são incorporados no pipeline de validação instantânea, impedindo que dados não autorizados influenciem as saídas de IA.
• Os controles de acesso baseados em funções, atributos e relações são aplicados, garantindo que apenas os parâmetros aprovados passem para a IA.
• Qualquer violação de políticas é registrada e bloqueada em tempo real, preservando um rastro auditável de decisões de acesso.




Aqui estão os três métodos para filtrar prompts - do mais fácil ao mais avançado:




1. Validação de token - Um método eficiente para verificações simples como o comprimento do prompt ou a permissão geral de entradas em execução no sistema. Funções de verificação de permissão neste método examinam os atributos estruturados de prompts textuais.
2. Pattern Matching - neste método, a verificação de permissão examina padrões no texto do prompt. Verificando, por exemplo, se o padrão corresponde a uma consulta SQL ou exemplo de código.
3. Classificação de IA - o método mais avançado nesta lista, a classificação de IA usa a IA para analisar o prompt usando um prompt de sistema dedicado, classificando nele uma entrada estruturada
4. Validação de token - Um método eficiente para verificações simples como comprimento de prompt ou a permissão geral de entradas em execução no sistema.Validação de token
5. Pattern Matching - neste método, a verificação de permissão examina padrões no texto da mensagem.Patrimônio de correspondência
6. Classificação de IA - o método mais avançado nesta lista, a classificação de IA usa a IA para analisar o prompt usando um prompt de sistema dedicado, classificando-o em uma entrada estruturada que pode ser analisada com precisão na verificação de permissões.
Classificação da IA











Filtração rápida com PydanticAI

Filtração rápida com PydanticAI

Para melhor demonstrar a implementação de filtragem de prompt eficiente, aqui está um exemplo de usar ferramentas PydanticAI para filtrar entradas de usuários para agentes de IA. PydanticAI é um framework de agentes que aproveita a famosa biblioteca Pydantic de Python e suas capacidades de digitação estática e a transforma em um framework de IA estruturado que lida com dados não estruturados.




The following GitHub repository contains a full implementation of the framework for PydanticAI: github.com/permitio/permit-pydanticai

github.com/permitio/permit-pydanticai




 @financial_agent.tool async def validate_financial_query( ctx: RunContext[PermitDeps], consulta: FinancialQuery, ) -> bool: ""Cheques chave: - Usuário optou explicitamente para aconselhamento financeiro de IA, Falso de outra forma "" tente: #Classifique se o prompt está solicitando aconselhamento_seeking_advice = classify_promptfor_vice(query.vice) retorna informações Args: ctx: Contexto contendo Permit cliente e consulta de ID do usuário: A consulta financeira para validar Returns: bool: True se o usuário concordou com aconselhamento de IA, Falso de outra forma ""
@financial_agent.tool
async def validate_financial_query(
    ctx: RunContext[PermitDeps],
    query: FinancialQuery,
) -> bool:
    """Key checks:
    - User has explicitly opted in to AI financial advice
    - Consent is properly recorded and verified
    - Classifies if the prompt is requesting advice

    Args:
        ctx: Context containing Permit client and user ID
        query: The financial query to validate

    Returns:
        bool: True if user has consented to AI advice, False otherwise
    """
    try:
        # Classify if the prompt is requesting advice
        is_seeking_advice = classify_prompt_for_advice(query.question)

        permitted = await ctx.deps.permit.check(
            # The user object with their attributes
            {
                "key": ctx.deps.user_id,
            },
            # The action being performed
            "receive",
            # The resource being accessed
            {
                "type": "financial_advice",
                "attributes": {"is_ai_generated": is_seeking_advice},
            },
        )

        if not permitted:
            if is_seeking_advice:
                return "User has not opted in to receive AI-generated financial advice"
            else:
                return "User does not have permission to access this information"

        return True

    except PermitApiError as e:
        raise SecurityError(f"Permission check failed: {str(e)}")
2. Enforce Proteção de Dados –
2. Enforce Proteção de Dados –
A seguir, protegemos as consultas de geração aumentada de recuperação (RAG) garantindo que os modelos de IA só possam acessar fontes de conhecimento autorizadas. Isto pode ser alcançado através da filtragem finamente granulada dos dados do agente de IA em nome do usuário no fluxo de trabalho de IA:
Geração de recuperação aumentada (RAG)Fontes de conhecimento autorizadas
 
 
 
A política finamente granulada usa modelos avançados de filtragem de dados, como controle de acesso baseado em relações, para permitir a filtragem avançada de consultas para o mecanismo de políticas.
 
As fontes vetoriais e gráficas conectadas aos agentes de IA têm metadados que podem ajudar o mecanismo a manipular a consulta não estruturada, filtrando-a para incluir apenas dados permitidos.
 
Toda vez que o agente obtém dados da base de conhecimento RAG, ele filtra os resultados com a permissão do usuário.
 
A política de grãos finos usa modelos avançados de filtragem de dados, como controle de acesso baseado em relacionamento, para permitir filtragem avançada de consulta para o motor de políticas.
As fontes vetoriais e gráficas conectadas aos agentes de IA têm metadados que podem ajudar o motor a manipular a consulta não estruturada, filtrando-a para incluir apenas dados permitidos.
Cada vez que o agente obtém dados da base de conhecimento RAG, ele filtra os resultados por permissão do usuário.
 
 
Quando o aplicativo do agente realiza a filtragem RAG, ele usa um dos seguintes métodos:
 
 
 
FilterObjects—Neste método, o aplicativo gráfico recolhe todos os dados relevantes do RAG e, em seguida, filtra por permissões de usuário. A vantagem desta função é que mantém o motor de políticas sem status e sem conhecimento de dados RAG.
 
GetUserPermissions - Neste método, o agente fornece ao RAG uma consulta não estruturada. O RAG chama a função GetUserPermissions, anexando uma consulta de filtro à consulta RAG não estruturada. Isto permite que a consulta seja filtrada apenas para os recursos aos quais o usuário pode acessar.
 
FilterObjects—Neste método, o aplicativo de gráficos obtém todos os dados relevantes do RAG e, em seguida, filtra-os por permissões de usuário.FilterObjects
GetUserPermissions - Neste método, o agente fornece ao RAG uma consulta não estruturada. O RAG então chama a função GetUserPermissions, anexando uma consulta de filtro à consulta RAG não estruturada.GetUserPermissionsGetUserPermissions
 
 
Proteção de dados RAG com Langchain
Proteção de dados RAG com Langchain
Langchain, o famoso framework de aplicações de IA, é conhecido (também) por seus componentes de retriever que fornecem grande suporte em retrievers personalizados que podem ser montados com qualquer tipo de fonte de dados, tornando a implementação de RAG seguro fácil. Por exemplo, com o SelfQueryRetriever, você pode envolver o RAG usual com uma função GetUserPermissions que anexará os dados filtrados à consulta.SelfQueryRetrieverGetUserPermissions
 # 1. Construa uma pequena loja de inserções de vetores na memória = OpenAIEmbeddings() vectorstore = FAISS.from_documents(docs, embedding=embeddings) # 2. Inicialize o PermitSelfQueryRetriever retriever = PermitSelfQueryRetriever( api_key=os.getenv("PERMIT_API_KEY", ""), pdp_url=os.getenv("PERMIT_PDP_URL"), user=USER, resource_type=RESOURCE_TYPE, action=ACTION, llm=embeddings, vectorstore=vectorstore, enable_limit=False, 

# 1. Build a small in-memory vector store
  embeddings = OpenAIEmbeddings()
  vectorstore = FAISS.from_documents(docs, embedding=embeddings)

# 2. Initialize the PermitSelfQueryRetriever
retriever = PermitSelfQueryRetriever(
    api_key=os.getenv("PERMIT_API_KEY", ""),
    pdp_url=os.getenv("PERMIT_PDP_URL"),
    user=USER,
    resource_type=RESOURCE_TYPE,
    action=ACTION,
    llm=embeddings,
    vectorstore=vectorstore,
    enable_limit=False,
)
 
 
The following repository contains the full implementation of the framework for Langchain: https://github.com/permitio/langchain-permit
https://github.com/permitio/langchain-permit
3. Segurança do acesso externo –
 3. acesso externo seguro –
Agentes de IA freqüentemente interagem com APIs, serviços e ferramentas de automação externas. Sem um controle de acesso adequado, eles correm o risco de executar ações não autorizadas.
 
 

Using models like MCP, which defines a server-client model where AI agents interact with external services, is a great step in enabling security for AI external access (e.g., databases, APIs, payment systems).
The AI action infrastructure can use a service like Permit.io to perform authorization checks at the action level, checking who’s making a request and what action they want to perform.
Developers are able to assign machine identities to AI agents, limiting their capabilities to pre-approved functions only.
Usar modelos como o MCP, que define um modelo servidor-cliente onde os agentes de IA interagem com serviços externos, é um grande passo para permitir a segurança para o acesso externo da IA (por exemplo, bancos de dados, APIs, sistemas de pagamento).
The AI action infrastructure can use a service like Permit.io to perform authorization checks at the action level, checking who’s making a request and what action they want to perform.
Permit.ioOs desenvolvedores são capazes de atribuir identidades de máquina a agentes de IA, limitando suas capacidades apenas a funções pré-aprovadas.
 
 
Enquanto GPTs e interfaces de linguagem natural não são novas, deixá-los executar ações em nome dos usuários é um desafio relativamente novo muitos engenheiros lutam com. Podemos notar três níveis distintos de controle de acesso importante para garantir aqui:
 
 
 
 Segurança de acesso direto - o nível mais simples. Um usuário pede a um agente de IA para realizar uma operação, como uma chamada HTTP. O agente de IA sabe verificar se a operação é permitida, considerando o contexto atual e o usuário.
 
 Comunicação de agente a agente - neste próximo nível, exigimos um fluxo de identidades e permissões em cascata que permitam que os agentes realizem ações por conta própria com base no princípio do menor privilégio. Neste nível, gostaríamos de usar a relação entre identidades - humano e não-humano - para cascadar diferentes níveis de permissões.
 
 Fluxos de solicitação de acesso - o nível mais
Segurança de acesso direto - o nível mais simples.Um usuário pede a um agente de IA para realizar uma operação, como uma chamada HTTP.O agente de IA sabe verificar se a operação é permitida, considerando o contexto atual e o usuário.
Segurança de acesso direto
Comunicação agente-a-agente - neste próximo nível, exigimos um fluxo em cascata de identidades e permissões que permitam que os agentes realizem suas próprias ações com base no princípio do menor privilégio.Comunicação de agente a agente
Fluxos de solicitação de acesso - o nível mais emocionante de acesso externo é quando o agente de IA entende a necessidade de solicitar acesso diretamente a um usuário humano quando quer realizar uma operação.Fluxos de solicitação de acesso
 
 
MCP, Human-in-the-Loop e Acesso Externo
MCP, Human-in-the-Loop e acesso externo
Model Context Protocol é um novo protocolo introduzido pela Anthropic, que resolve o problema de permitir que os agentes de IA realizem ações proativas e serve como o maior facilitador para garantir o acesso externo.
 
 
No exemplo a seguir, mostramos um servidor MCP que sabe como gerenciar fluxos de solicitações de acesso, trazendo humanos para o loop e usando as APIs do Permit.io para solicitar permissões.
 
 
You can see the full code example for the MCP access request server here: https://github.com/permitio/permit-mcp
https://github.com/permitio/permit-mcp
 
 
@mcp.tool() async def request_access(username: str, resource_name: str) -> dict: "" Iniciar a chamada de solicitação de acesso a um recurso específico no sistema Args: nome de usuário: o nome de usuário da pessoa que solicita o recurso de acesso: o tipo de recurso que o usuário solicita o acesso para resource_name: o nome do restaurante para solicitar o acesso para """ = wait permit.elements.login_as({ "userId": slugify(nome de usuário), "tenente": "default"}) print(login_sign_on_head) url ="https://.permit.io/v2/facts/{PROJECT_ID}/{ENV@mcp.tool()
async def request_access(username: str, resource: str, resource_name: str) -> dict:
  """
  Initiate access request call to a specific resource in the system

  Args:
    username: The username of the person requesting access
    resource: The resource type the user is request access for
    resource_name: The name of the restaurant to request access for

  """
  
  login = await permit.elements.login_as({ "userId": slugify(username), "tenant": "default"})
  print(login)
  
  url = f"https://api.permit.io/v2/facts/{PROJECT_ID}/{ENV_ID}/access_requests/{ELEMENTS_CONFIG_ID}/user/{slugify(username)}/tenant/default"
  payload = {
      "access_request_details": {
          "tenant": "default",
          "resource": resource,
          "resource_instance": resource_name['id'],
          "role": "viewer",
      },
      "reason": f"User {username} requests role 'viewer' for {resource_name}"
  }
  headers = {
      "authorization": "Bearer YOUR_API_SECRET_KEY",
      "Content-Type": "application/json",
  }
  async with httpx.AsyncClient() as client:
      await client.post(url, json=payload, headers=headers)
      return "Your request has been sent. Please check back later."
4 Validação de respostas de IA –
4 Validar as respostas de IA –
O perímetro final impõe moderação de conteúdo e conformidade em respostas geradas por IA. Isto pode ser feito criando um fluxo de trabalho que aplica filtragem baseada em políticas antes de entregar saídas de IA:
 
 
 
Um controle de permissão pode ser adicionado à aplicação do agente, permitindo a aplicação de políticas em cada etapa da cadeia antes que o usuário realmente receba uma resposta.
 
Fluxos de trabalho de validação de dados e autorização combinados garantem que apenas dados validados e permitidos possam avançar.
 
A resposta que retorna aos usuários pode ser editada com base em limitações pré-definidas, permitindo assim a ocultação de dados ou notificando o usuário de limitações de uso.
 
Um controle de permissão pode ser adicionado ao aplicativo do agente, permitindo a aplicação de políticas em cada etapa da cadeia antes que o usuário realmente receba uma resposta.
Os fluxos de trabalho de validação de dados e autorização combinados garantem que apenas os dados validados e permitidos possam avançar.
A resposta que retorna aos usuários pode ser editada com base em limitações predefinidas, permitindo assim a ocultação de dados ou notificando o usuário de limitações de uso.
 
 
 
 
Filtramento de resposta com Langflow
Filtramento de resposta com Langflow
In the following example, we use Langflow, a visual no-code AI applications editor, to create a permissions check component that’s positioned before any chat response to the user. Using LangFlow's friendly flow modeling capabilities, you can easily append another component that masks unwanted details in returned responses. This repository contains all the access control components required for secured Langflow applications.
This repository
 
 
Conclusão
Os sistemas de IA estão se integrando rapidamente em aplicações em todas as indústrias, mas seus quadros de segurança permanecem subdesenvolvidos em comparação com o software tradicional.Sem um controle de acesso consciente da identidade adequado, os agentes de IA correm o risco de expor dados sensíveis, executar operações não autorizadas e gerar respostas que ficam fora das diretrizes de conformidade.
 
 
O Quadro de Quatro Perímetros oferece uma maneira estruturada de proteger os fluxos de trabalho de IA em todas as fases – desde a validação de prompts e a proteção de dados de geração aumentada por recuperação (RAG) até o controle de ações externas impulsionadas por IA e a aplicação da conformidade de resposta.
 
 
Instead of building access control from scratch, Permit.io’s AI Access Control integrations with PydanticAI, LangChain, MCP, and LangFlow allow teams to embed security directly into their AI applications—without disrupting development workflows. Try it yourself here.
Try it yourself here
 
 
Dito isto, este campo ainda é relativamente novo, e as melhores práticas para proteger os agentes de IA ainda estão evoluindo.O Quadro de Quatro Perímetros é uma abordagem experimental, e embora forneça uma base sólida, reconheço que as implementações do mundo real sempre exigem mais refinamento e adaptação.
 
 
I’d love to hear your feedback, thoughts, and ideas on how to improve this framework to make it even better for production-ready AI systems - comment here, or hit me up in our Slack community.
Slack community