Os axentes de IA non están listos para a produción - e o control de acceso pode ser a razón

-Daniel Bass

Páxinas que ligan con "Daniel Bass

A mellora do rendemento das aplicacións a través do uso de axentes de IA está a converterse nunha práctica moi común - xa sexa debido ao hype en toda a industria ou casos de uso útiles 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.

AI assistants expose sensitive patient informationsophisticated prompt injection attacks

Protexer os axentes de IA neste contexto está a ser tan importante como as capacidades dos propios axentes de IA - se non máis.

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:

Permit.io

The Four-Perimeter Framework.

The Four-Perimeter FrameworkThe 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.

fine-grained access control

O problema: riscos de seguridade de IA en dominios sensibles

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.

role-based access control (RBAC)

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.

attribute-based

Outra preocupación son os novos vectores de ataque que introducen os sistemas de IA. As medidas de seguridade convencionais non foron deseñadas para manexar ataques de inxección rápida, intentos de extracción de modelos ou ataques de intoxicación de datos.

A solución vén en forma dun marco de seguridade integral construído ao redor de catro perímetros esenciais -

A solución: o marco de catro perímetros

Como as aplicacións de IA difiren do software estándar en como procesan entradas, recuperan datos, executan accións e xeran saídas, tamén introducen riscos de seguridade únicos.Para abordar estes retos, necesitamos un enfoque de seguridade estruturado que aplique control de acceso en cada etapa da interacción de IA. E iso é exactamente o que quero mostrar aquí:

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.

Cámara de catro perímetrosfine-grained authorization throughout the AI lifecycle

O cadro consta de catro partes:

1. Prompt Filtering - Garantir que só as entradas seguras validadas cheguen a modelos de IA.
2. RAG Data Protection - Controlar o acceso de IA a fontes de coñecemento externas.
3. Secure External Access - Definir permisos de axentes de IA cando interactúan con ferramentas externas.
4. Response Enforcement - Aplicar controis de conformidade e filtrar as saídas xeradas por IA.

Filtrado rápido - Garantir que só as entradas seguras validadas cheguen aos modelos de IA.

Filtrado rápido

Protección de datos RAG - Controlar o acceso da IA a fontes de coñecemento externas.

RAG Protección de datos

Acceso externo seguro - Definición de permisos de axente de IA ao interactuar con ferramentas externas.

Acceso externo seguro

Response Enforcement - Aplicando comprobacións de conformidade e filtrando as saídas xeradas por IA.

Reflexións sobre a resposta

Aplicando os principios de control de acceso finamente granulado (FGA) a través destes perímetros, os axentes de IA permanecen seguros, audibles e conformes sen sacrificar a súa flexibilidade e funcionalidade.Control de acceso de gran fino (FGA)Seguro, audible e conforme

Onde entra o FGA?

Como se mencionou anteriormente, os métodos tradicionais de control de acceso como o RBAC non poden xestionar o comportamento dinámico e contextual da IA. É aquí onde entra en xogo a autorización de gran fino (FGA), especificamente a través do control de acceso baseado en atributos (ABAC) e o control de acceso baseado en relacións (ReBAC):

• ABAC para Prompt Filtering Os modelos de IA procesan entradas non estruturadas, o que dificulta a aplicación de regras de seguridade tradicionais.Os modelos de IA procesan entradas non estruturadas, o que dificulta a aplicación de regras de seguridade tradicionais.A ABAC resolve isto extraendo atributos estruturados de prompts de IA e usándoos en decisións de acceso baseadas en políticas.ABAC para filtración prompt

  
  

  • ReBAC para protección de datos RAG A xeración aumentada de recuperación (RAG) permite que os modelos de IA extraan información de bases de datos vectoras. ReBAC proporciona unha forma natural de fortalecer a seguridade nesta configuración definindo relacións entre usuarios, fontes de datos e axentes de IA. En lugar de asignar permisos estáticos, ReBAC dinámicamente concede ou nega o acceso en función de como os obxectos de datos se relacionan entre si, permitindo permisos de recuperación conscientes do contexto.
  ReBAC para protección de datos RAG A xeración aumentada de recuperación (RAG) permite que os modelos de IA extraan información de bases de datos vectoras. ReBAC proporciona unha forma natural de aplicar a seguridade nesta configuración definindo relacións entre usuarios, fontes de datos e axentes de IA. En lugar de asignar permisos estáticos, ReBAC dinámicamente concede ou nega o acceso en función de como os obxectos de datos se relacionan entre si, permitindo permisos de recuperación conscientes do contexto.
ReBAC para protección de datos RAG




Ao combinar ABAC e ReBAC, as aplicacións de IA obteñen mecanismos flexibles de control de acceso baseados en políticas que se adaptan a diferentes fluxos de traballo de IA sen necesidade de intervención manual.




Como é unha implementación paso a paso?

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.

Four-Perimeter Framework en acciónvalidar as indicacións, facer cumprir a protección de datos, restrinxir o acceso externo e moderar as respostasPermit.io AI Access ControlPermit.io

1. Implementación do filtro de prompt

1. Implementar filtracións de prompt

O primeiro perímetro de seguridade céntrase en validar e sanitar as entradas de IA antes de que cheguen ao modelo.




Os controis de autorización están incorporados ao tubo de validación inmediata, evitando que os datos non autorizados inflúan nas saídas de IA.
• O control de acceso baseado en roles, atributos e relacións é aplicado, garantindo que só os parámetros aprobados pasen á IA.
• Calquera violación de políticas é rexistrada e bloqueada en tempo real, preservando un rastro audible de decisións de acceso.

Os controis de autorización están incorporados á vía de validación inmediata, evitando que os datos non autorizados inflúan nas saídas de IA.

O control de acceso baseado en roles, atributos e relacións é aplicado, garantindo que só os parámetros aprobados pasen á IA.

Calquera violación de políticas é rexistrada e bloqueada en tempo real, preservando un rastro audíbel de decisións de acceso.

Aquí están os tres métodos para filtrar prompts - do máis sinxelo ao máis avanzado:

1. Validación de tokens - Un método eficiente para comprobacións sinxelas como a lonxitude do prompt ou a tolerancia xeral de entradas en execución no sistema. As funcións de comprobación de permisos neste método examinan os atributos estruturados dos prompts textuais.
2. Matching de patróns - neste método, o control de permisos examina os patróns no texto do prompt. Verificando, por exemplo, se o patrón coincide cunha consulta SQL ou exemplo de código.
3. Clasificación AI - o método máis avanzado nesta lista, a clasificación de IA usa a IA para analizar o prompt usando un prompt do sistema dedicado, clasificando nela unha entrada estruturada que
4. Validación de tokens - Un método eficiente para comprobacións sinxelas como a lonxitude do prompt ou a tolerancia xeral de entradas en execución no sistema.
Avaliación de tokens
5. Pattern Matching - neste método, a verificación de permisos examina os patróns no texto prompt.Pattern Matching Páxina webA clasificación de IA é o método máis avanzado nesta lista, a clasificación de IA utiliza a IA para analizar o prompt usando un prompt de sistema dedicado, clasificándoo nunha entrada estruturada que pode ser analizada con precisión na verificación de permisos.Clasificación da IA

   
   

   

   

   
   

   Filtrado rápido con PydanticAI

   Filtrado rápido con PydanticAI

   Para demostrar mellor a implementación da filtración de prompt eficiente, aquí está un exemplo de usar as ferramentas PydanticAI para filtrar as entradas do usuario aos axentes de IA. PydanticAI é un marco de axentes que aproveita a famosa biblioteca Pydantic de Python e as súas capacidades de escritura estática e convértea nun marco de IA estruturado que xestiona datos non 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 clave: - Usuario optou explicitamente para asesoramento financeiro AI, Falso doutro xeito "" tentar: #Classify se o prompt está a solicitar asesoramento_seeking_advice = información devolver asesoramento_promptforadvice(query.question) Contexto que contén Permit cliente e usuario ID de acceso: A consulta financeira para validar Returns: bool: verdadeiro se o usuario ten permiso para asesoramento de IA, Falso doutro xeito "" tentar: {{_se_ @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 Protección de datos –

   2. Enforzar a protección de datos –

   Seguinte, aseguramos as consultas de xeración aumentada de recuperación (RAG) asegurando que os modelos de IA só poidan acceder a fontes de coñecemento autorizadas.Xeración aumentada de recuperación (RAG)Fontes de coñecemento autorizados

   
   

   A política finamente granulada usa modelos avanzados de filtración de datos, como o control de acceso baseado en relacións, para permitir a filtración de consultas avanzadas ao motor de políticas.
6. As fontes vector e gráficas conectadas aos axentes de IA teñen metadatos que poden axudar ao motor a manipular a consulta non estruturada, filtrándoa para incluír só datos permitidos.
7. Cada vez que o axente obtén datos da base de coñecemento RAG, filtra os resultados por permiso do usuario.
A política finamente granulada utiliza modelos avanzados de filtración de datos, como o control de acceso baseado en relacións, para permitir a filtración avanzada de consultas ao motor de políticas.As fontes vector e gráficas conectadas aos axentes de IA teñen metadatos que poden axudar ao motor a manipular a consulta non estruturada, filtrándoa para incluír só datos permitidos.Cada vez que o axente obtén datos da base de coñecemento RAG, filtra os resultados por permiso do usuario.




Cando a aplicación do axente realiza a filtración RAG, utiliza un dos seguintes métodos:




• FilterObjects—Neste método, a aplicación gráfica obtén todos os datos relevantes do RAG e logo filtra por permisos de usuario. A vantaxe desta función é que mantén o motor de políticas sen estado e sen coñecemento dos datos RAG.
• GetUserPermissions - Neste método, o axente proporciona ao RAG unha consulta non estruturada. O RAG chama a función GetUserPermissions, anexando unha consulta de filtro á consulta RAG non estruturada. Isto permite que a consulta sexa filtrada só aos recursos aos que o usuario pode acceder.
8. FilterObjects—Neste método, a aplicación gráfica obtén todos os datos relevantes do RAG e, a continuación, filtra por permisos de usuario.FilterObjects
9. GetUserPermissions - Neste método, o axente proporciona á RAG unha consulta non estruturada. A RAG chama a función GetUserPermissions, anexando unha consulta de filtro á consulta RAG non estruturada.GetUserPermissionsGetUserPermissions

   
   

   

   

   Protección de datos RAG con Langchain

   Protección de datos RAG con Langchain

   Langchain, o famoso marco de aplicacións de IA, é coñecido (tamén) polos seus compoñentes de retriever que proporcionan un gran soporte en retrievers personalizados que poden ser montados con calquera tipo de fonte de datos, o que facilita a implementación de RAG seguro. Por exemplo, co SelfQueryRetriever, pode envolver o RAG habitual cunha función GetUserPermissions que anexará os datos filtrados á consulta.SelfQueryRetrieverGetUserPermissions

    # 1. Construír unha pequena in-memory vector store embeddings = OpenAIEmbeddings() vectorstore = FAISS.from_documents(docs, embedding=embeddings) # 2. Iniciar o PermitSelfQueryRetriever retriever = PermitSelfQueryRetriever( api_key=os.getenv("PERMIT_API_KEY", ""), pdp_url=os.getenv("PERMIT_PDP_URL"), usuario=USER, resource_type=RESOURCE_TYPE, acción=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. Acceso externo seguro –

   3. Acceso externo seguro –Os axentes de IA a miúdo interactúan con APIs, servizos e ferramentas de automatización externas. Sen un control de acceso adecuado, corren o risco de executar accións non 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.
   Usando modelos como o MCP, que define un modelo servidor-cliente onde os axentes de IA interactúan con servizos externos, é un gran paso para permitir a seguridade para o acceso externo de IA (por exemplo, bases de datos, APIs, sistemas de pagamento).
10. 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 son capaces de asignar identidades de máquina aos axentes de IA, limitando as súas capacidades a funcións pre-aprovadas só.




Aínda que os GPT e as interfaces de linguaxe natural non son novas, permitirlles realizar accións en nome dos usuarios é un reto relativamente novo que moitos enxeñeiros loitan con.




1. Seguridade de acceso directo - o nivel máis sinxelo. Un usuario pide a un axente de IA que realice unha operación, como unha chamada HTTP. O axente de IA sabe comprobar se a operación está permitida, tendo en conta o contexto actual e o usuario.
2. Comunicación de axente a axente - neste seguinte nivel, necesitamos un fluxo de identidades e permisos que permitan aos axentes realizar accións por si mesmos baseados no principio do privilexio mínimo. Neste nivel, queremos usar a relación entre identidades - humano e non humano - para cascadar diferentes niveis de permisos.
3. Fluxos de solicitude de acceso - o nivel máis emocionante de acceso externo éUn usuario pide a un axente de IA que realice unha operación, como unha chamada HTTP. O axente de IA sabe comprobar se a operación está permitida, tendo en conta o contexto actual e o usuario.Seguridade de acceso directo
4. Comunicación de axente a axente - neste seguinte nivel, necesitamos un fluxo de identidades e permisos que permitan aos axentes realizar as súas propias accións baseadas no principio do privilexio mínimo.Comunicación de axente a axente
5. Fluxos de solicitude de acceso - o nivel máis emocionante de acceso externo é cando o axente de IA entende a necesidade de solicitar acceso directamente a un usuario humano cando quere realizar unha operación.Fluxos de solicitude de acceso

   
   

   

   

   MCP, Human-in-the-Loop e acceso externo

   MCP, Human-in-the-Loop e acceso externoModel Context Protocol é un novo protocolo introducido por Anthropic, que resolve o problema de permitir que os axentes de IA realicen accións proactivas e serve como o maior facilitador para asegurar o acceso externo.

   
   

   No seguinte exemplo, mostramos un servidor MCP que sabe como xestionar os fluxos de solicitudes de acceso introducindo humanos no loop e usa as APIs de Permit.io para solicitar permisos.

   
   

   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: "" Inicia a chamada de solicitude de acceso a un recurso específico no sistema Args: nome de usuario: o nome de usuario da persoa que solicita o recurso de acceso: o tipo de recurso que o usuario solicita o acceso a resource_name: o nome do restaurante para solicitar o acceso a """ = wait permit.elements.login_as({ "userId": slugify(username), "tenente": "default"}) imprime(login_senton_head) url = "https://pay.permit.io/v2/facts/{PROJECT_ID}/{ENV_ID}/@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 Validar as respostas de IA –
   4 Validar as respostas AI –
   O perímetro final impón a moderación do contido e o cumprimento das respostas xeradas por IA. Isto pódese facer creando un fluxo de traballo que aplica a filtración baseada en políticas antes de entregar as saídas de IA:
    
    
    
   Pódese engadir unha verificación de permisos á aplicación do axente, permitindo a aplicación de políticas en cada paso da cadea antes de que o usuario reciba realmente unha resposta.
    
   Os fluxos de traballo combinados de validación de datos e autorización aseguran que só os datos validados e permitidos poden avanzar.
    
   A resposta que regresa aos usuarios pode ser editada baseándose en limitacións predefinidas, permitindo así o mascaramento de datos ou notificando ao usuario das limitacións de uso.
    
   Pódese engadir unha verificación de permisos á aplicación do axente, permitindo a aplicación de políticas en cada paso da cadea antes de que o usuario reciba realmente unha resposta.
   Os fluxos de traballo de validación e autorización de datos combinados aseguran que só os datos validados e permitidos poden avanzar.

A resposta que regresa aos usuarios pode ser editada baseándose en limitacións predefinidas, permitindo así a mascarada de datos ou notificando ao usuario das limitacións de uso.











Filtrado de resposta con Langflow

Filtrado de resposta con 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








Conclusións

Os sistemas de IA están a integrarse rapidamente en aplicacións en todas as industrias, pero os seus marcos de seguridade permanecen subdesenvolvidos en comparación co software tradicional. sen un control de acceso consciente da identidade adecuado, os axentes de IA corren o risco de expoñer datos sensibles, executar operacións non autorizadas e xerar respostas que caen fóra das directrices de cumprimento.




O Marco de catro perímetros ofrece unha forma estruturada de protexer os fluxos de traballo de IA en todas as fases, desde a validación de prompts e a protección de datos de xeración aumentada por recuperación (RAG) ata o control de accións externas impulsadas por IA e a aplicación 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 aínda é relativamente novo, e as mellores prácticas para asegurar os axentes de IA aínda están evolucionando.O Marco de catro perímetros é un enfoque experimental, e aínda que proporciona unha base sólida, recoñezo que as implementacións do mundo real sempre requiren máis refinamento e adaptación.




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