ZICQ
中 Log in / Sign up
Newsroom Agentic #AgentCore Gateway #Data De-Identification #Agent Security #MCP #Privacy Engineering

Skyflow Secures Agent Tool Boundaries with Three-Layer De-Identification on AgentCore Gateway

Avatar of Mr.Xu

By Mr.Xu Compiled & Reviewed by Editorial

Published:

中文阅读 (Chinese) English Version
Co-reading Select any sentence in the article to highlight, annotate, or copy a quote card. Join discussion ↓

Summary:Amazon Bedrock AgentCore Gateway can now use an open-source Skyflow interceptor to enforce data protection at both sides of every mediated tool call. The interceptor invokes Skyflow Detect before requests reach external tools, restores authorized values before responses reach the agent, and can replace signed document URLs with links to de-identified copies. The architecture offers three modes: Shield the tool for third-party APIs and search, Shield the model for prompts, history, files, and to


Put Data Governance on the Shared Tool-Call Data Plane

Amazon Bedrock AgentCore Gateway's new integration does not ask every agent framework to implement its own filtering layer. Instead, it places a Skyflow interceptor on the shared path through which tool calls travel. Before a request reaches an external tool, the interceptor can de-identify its arguments; before a response reaches the agent, it can restore authorized values or replace a document link with a sanitized copy.

This design targets three leakage paths that model-centric safeguards often miss:

  1. Tool arguments: the model may copy names, account identifiers, or email addresses from context into a search query or third-party API request even though those fields are unnecessary.
  2. Tool results: web pages, CRM records, and case notes can inject unrelated personal data into model context, memory, traces, and logs.
  3. Signed document URLs: a document tool returns a URL rather than text, allowing a string filter to pass while the agent later opens the original file.

The interceptor is an AWS Lambda function attached to both the Gateway's REQUEST and RESPONSE interception points. The request interceptor transforms outbound arguments, while the response interceptor handles inbound results and document URLs. Existing agents can continue discovering the Gateway through their existing IAM roles, and tools do not need to understand Skyflow's token format.

Three Shield Modes Define Different Trust Boundaries

Shield the tool: External services receive tokens

Skyflow Detect replaces names, email addresses, phone numbers, government identifiers, card numbers, dates of birth, and locations in outbound arguments with Vault Tokens. A third-party search service or API receives a placeholder such as [NAME_AJbrIud] rather than the original identity.

If the tool echoes that token in its response, the interceptor restores the original value before the agent reads the result. This preserves identity-dependent workflows without exposing cleartext to the external service. The tradeoff is that Vault Tokens are reversible references: strict schema validation, fixed-length fields, or database joins against original identifiers may reject them. Every production tool contract therefore needs a separate compatibility test.

Shield the model: Model context becomes a protected data plane

Protecting tools alone is insufficient because web content, case notes, and conversation history eventually enter the model request. Shield the model requires an inference target on the Gateway and directs the agent's model client to the Gateway inference endpoint. The interceptor then de-identifies prompts, conversation history, files, and tool results.

On the return path, it restores only the tokens minted for that call. DynamoDB records the relationship between a model invocation and its generated tokens, but the record contains no original sensitive values. This per-call scoping avoids accidentally restoring a token created by another session.

A crucial caveat is that the agent code does not have to be rewritten, but its model client does have to use the Gateway endpoint. Direct calls to Bedrock or another model endpoint bypass this protection.

Shield the document: Inspect the object behind the URL

A signed URL exposes little sensitive text, but the object behind it may contain exactly the data the policy is meant to protect. Shield the document validates the presigned URL against an allowlist and checks its size before asking Skyflow Detect to fetch the file, produce a de-identified copy, and store that copy in an approved Region.

The file bytes do not pass through Lambda, so the function payload limit does not determine the maximum file size. Actual bounds come from the configured size limit, the AgentCore Gateway connection window, document processing time, and storage costs. The agent receives a link to the clean copy instead of the original object.

String de-identification and re-identification are generally available, while document de-identification through signed URLs depends on Skyflow Detect v2, which remains in preview. TXT, JSON, CSV, XML, JSONL, DOCX, XLSX, and PPTX retain reversible Vault Tokens. PDFs and images are fully de-identified but receive one-way tokens that cannot be reversed.

Policies, Secrets, and Failure Behavior

The reference implementation uses AWS-native components:

  • Amazon SSM Parameter Store stores per-tool and per-MCP-server policies, including protection direction, entity types, and reversible versus one-way token selection. Policy changes do not require an agent redeployment.
  • AWS Secrets Manager holds the Skyflow API key, so agents do not manage that credential.
  • Amazon DynamoDB stores model-call token relationships without storing the original values.
  • Amazon CloudWatch records interceptor decisions, metrics, and alarms alongside AgentCore Gateway traces.
  • AWS IAM remains the authorization boundary; the Gateway role needs permission to invoke the designated interceptor.

The interceptor follows a Fail Closed policy. If de-identification cannot complete, a document URL is not allowlisted, or traffic cannot be inspected, the request is blocked rather than forwarded in cleartext. This is the correct default for tightly regulated data, but it also makes Detect, Vault, DynamoDB, and network connectivity part of the tool's availability path. A detection failure becomes a business outage rather than merely a privacy incident. Production deployments must make that trade-off explicit instead of falling back to permissive behavior.

Authorization and Data Transformation Are Different Layers

Skyflow does not replace AgentCore Policy or Bedrock Guardrails; it adds a data-transformation layer between authorization and execution.

AgentCore Policy, using Cedar and Dogwood, determines whether an agent may invoke a capability, pass particular arguments, or continue along the current trajectory. Bedrock Guardrails apply content-safety and sensitive-information controls to model interactions. Skyflow then converts approved cleartext arguments into controlled tokens and restores authorized values on the return path.

In other words, Policy answers whether an action is allowed, while Skyflow controls how sensitive data moves once the action is allowed. This separation avoids placing the entire security burden on prompt instructions or an agent-local output filter.

Engineering Trade-offs: Another Protection Layer, Another Critical Path

For a synchronous tool call, end-to-end latency can be approximated as:

T_total ≈ T_detect(request) + T_tool + T_detect(response) + T_vault(restore)

De-identification is therefore on the critical path rather than in a background side channel. Model protection adds a request transformation and a response restoration on top of inference. The post provides no P50/P95 latency, concurrency throughput, Skyflow API quota, or Lambda scaling data, so the practical impact on high-frequency customer service, batch processing, and real-time search remains unquantified.

| Concern | Benefit | Cost or risk | |---|---|---| | Bidirectional interception | Controls both outbound arguments and returned results | Adds latency and external-service dependencies | | Fail Closed | Prevents cleartext forwarding after a detection failure | A dependency outage directly reduces tool availability | | Reversible Vault Tokens | Preserve identity and business continuity | The Vault becomes a high-value sensitive asset requiring strict authorization and audit | | Sanitized document copies | Covers content hidden behind signed URLs | Adds fetching, parsing, storage, and lifecycle-management cost | | Dynamic policy | Changes protection scope without redeployment | Misconfiguration may cause over-redaction or coverage gaps |

Detection quality is equally important. The post does not report precision or recall for names, locations, multilingual text, nested entities, spreadsheet cells, or long documents. Excessive redaction can break entity linking and tool arguments; a missed entity directly invalidates the security premise. The bank's name-substitution example is an architectural walkthrough, not an accuracy benchmark.

Document cost depends on file size and format complexity. Detect v2's processing time grows with document volume, while fetching, parsing, and storing the sanitized copy introduce additional network and object-storage overhead. Keeping file bytes out of Lambda addresses the function payload limit, not the end-to-end latency or processing bill.

The Published Evidence Still Lacks Quantitative Validation

The AWS and Skyflow post covers requests, responses, model calls, documents, MCP servers, and CloudWatch operations. The MIT-licensed repository also provides a complete reference deployment. However, several figures required for a production decision are missing:

  • Precision, recall, and false-redaction rates across entity types, languages, and file formats;
  • P50, P95, and P99 latency after interception;
  • Per-Lambda concurrency, Vault API limits, and DynamoDB scaling boundaries;
  • Cost per million requests and per gigabyte of processed documents;
  • Tests for incorrect restoration, cross-session token leakage, and Vault authorization boundaries;
  • Detect v2 stability across Regions, document sizes, and concurrent loads.

The implementation is best treated as a deployable privacy control plane for AgentCore Gateway, not yet as an independently validated zero-trust data security system.

Deployment and Acceptance Path

  1. Inventory every egress: list all MCP servers, SaaS APIs, document stores, and model endpoints used by the agent, then identify which paths traverse the Gateway and which direct-access bypasses remain.
  2. Start with Shield the tool: select a low-risk workflow that calls external search or enrichment APIs, verify that each tool accepts the token format, and confirm that echoed tokens are restored correctly.
  3. Define a minimal policy: begin with the entity types that must leave the account, specify which fields each tool may see, and avoid enabling every detector class at once.
  4. Test model routing separately: move the model client to the Gateway inference target, confirm all calls traverse the interceptor, and test DynamoDB token scoping under multiple concurrent sessions.
  5. Add documents only after validation: configure URL allowlists and size limits for S3, Box, and Google Drive, then measure real DOCX, XLSX, PDF, and image workloads for latency and detection errors.
  6. Exercise failure modes: simulate Detect timeouts, Vault unavailability, DynamoDB write failures, and expired document URLs to verify that cleartext traffic is actually blocked.
  7. Observe continuously: track block rates, latency, policy changes, and de-identification outcomes in CloudWatch for at least one complete operational cycle before expanding coverage.

For teams already operating AgentCore Gateway, adoption is relatively straightforward: deploy the CDK stack, attach both interception points, and add an inference target only when model shielding is required. The decisive production questions are not the installation steps, but detection accuracy, failure policy, and whether direct-access bypasses have been eliminated.


Source: AWS Machine Learning Blog (2026-11-19)

— END —

Tags: #AgentCore Gateway #Data De-Identification #Agent Security #MCP #Privacy Engineering

Editorial & Fact-Checking Note: This article is compiled from primary research, official release documentation, and source papers by the ZICQ Newsroom pipeline with automated entity verification and human editorial review. If you notice any technical inaccuracy, please submit a correction via our corrections policy or email our editorial desk directly.

What's your take on this story?
🚀 Explore & Submit Works

Community Comments

Loading live comments and annotations…