2026年8月，AI Agent已接管企业核心决策链路，但OWASP最新报告显示，Agent专属攻击面同比激增340%——Prompt注入、工具链投毒、上下文窃取、权限越界成为新型威胁。传统"上线后补安全"的模式在Agent时代彻底失效。行业共识转向"安全左移"：在架构设计阶段即嵌入防御，让每个Agent天生具备抗攻击能力。安全不再是附加组件，而是智能体工程的第零层基础设施。

一、 Agent专属攻击面的四重威胁

1. "Prompt注入2.0"：从文本欺骗到结构化操纵

攻击者不再简单插入"忽略以上指令"，而是构造精心设计的JSON/Markdown结构，诱导Agent将恶意指令解析为合法工具参数；多轮对话中逐步"催眠"Agent，使其在第5轮执行前4轮明确拒绝的操作；Agent的CoT推理过程本身被注入隐蔽指令，导致"思考正确但执行错误"。根因：输入验证停留在字符串层面，未对结构化数据进行语义级净化。

2. "工具链投毒"：Agent的信任边界被穿透

恶意第三方工具伪装成合法API，返回包含隐藏指令的响应数据；知识库被植入带Prompt注入的文档，Agent检索后将其当作可信上下文执行；工具返回值中的元数据字段被利用，触发Agent未预期的行为分支。根因：Agent对工具输出默认信任，缺乏输出净化与行为沙箱。

3. "上下文窃取"：敏感信息通过推理泄露

攻击者通过精心设计的查询，诱导Agent在回复中复述系统Prompt、内部规则或历史对话中的敏感信息；Agent在多轮对话中无意拼接出用户隐私数据；CoT日志中包含密码、Token等凭证，被日志系统明文存储。根因：输出过滤仅检查最终回复，未覆盖中间推理过程与日志流。

4. "权限越界"：Agent执行了不该执行的操作

客服Agent被诱导调用财务系统的退款接口；只读分析Agent被操纵执行数据库写入操作；Agent在自主规划时"创造性地"组合工具，绕过预设的权限矩阵。根因：工具调用权限是静态配置，缺乏运行时意图验证与最小权限动态约束。

二、 防御架构：Agent安全五层纵深模型

┌────────────────────────────────────────────────────────────────────────────┐
│              2026 Agent Defensive Engineering: Five-Layer Model            │
├────────────────────────────────────────────────────────────────────────────┤
│                                                                            │
│  [External Input / User Request]                                           │
│       ↓                                                                    │
│  ┌─ L1: 输入净化层 (Input Sanitization) ────────────────────────────┐     │
│  │  • 结构化输入语义验证 (非字符串匹配)                              │     │
│  │  • 多轮对话状态机: 检测渐进式注入                                 │     │
│  │  • CoT输入隔离: 区分用户内容与系统指令                            │     │
│  └──────────────────────────────────────────────────────────────────┘     │
│       ↓                                                                    │
│  ┌─ L2: 执行沙箱层 (Execution Sandbox) ─────────────────────────────┐     │
│  │  • 工具调用白名单 + 参数Schema强校验                              │     │
│  │  • 输出净化: 工具返回值脱敏 + 指令剥离                            │     │
│  │  • 行为边界监控: 检测异常工具组合与调用模式                       │     │
│  └──────────────────────────────────────────────────────────────────┘     │
│       ↓                                                                    │
│  ┌─ L3: 权限治理层 (Permission Governance) ─────────────────────────┐     │
│  │  • 最小权限原则: 每Agent仅授予完成任务所需的最小工具集             │     │
│  │  • 运行时意图验证: 工具调用前校验是否符合当前任务上下文           │     │
│  │  • 敏感操作二次确认: 高风险动作需显式授权                         │     │
│  └──────────────────────────────────────────────────────────────────┘     │
│       ↓                                                                    │
│  ┌─ L4: 输出防护层 (Output Protection) ─────────────────────────────┐     │
│  │  • 敏感信息检测: 覆盖最终回复 + CoT + 日志                        │     │
│  │  • 系统Prompt防泄露: 相似度检测 + 正则兜底                        │     │
│  │  • 回复完整性校验: 防止被截断或篡改                               │     │
│  └──────────────────────────────────────────────────────────────────┘     │
│       ↓                                                                    │
│  ┌─ L5: 审计与响应层 (Audit & Response) ─────────────────────────────┐     │
│  │  • 全链路安全事件记录 (谁/何时/尝试了什么/结果如何)               │     │
│  │  • 实时告警 + 自动阻断 (高危攻击立即终止会话)                     │     │
│  │  • 攻击模式学习: 新威胁自动更新防御规则                           │     │
│  └──────────────────────────────────────────────────────────────────┘     │
│                                                                            │
└────────────────────────────────────────────────────────────────────────────┘


三、 实战1：结构化输入净化与渐进式注入检测引擎

：在Agent接收输入的瞬间完成语义级净化，阻断Prompt注入2.0与多轮催眠攻击。

pip install pydantic redis prometheus-client regex
# 基础设施: Redis (会话状态/黑名单) + Prometheus (安全指标) + SIEM (审计日志)


"""
agent_input_guard.py - Agent输入净化与渐进式注入检测
核心原则: 不信任任何输入，包括看起来合法的输入
"""
from typing import Dict, List, Any, Optional, Tuple
from enum import Enum
from dataclasses import dataclass, field
from pydantic import BaseModel, Field, field_validator
import re, time, uuid, json, hashlib


class ThreatLevel(str, Enum):
    SAFE = "safe"
    SUSPICIOUS = "suspicious"
    BLOCKED = "blocked"


class InjectionPattern(str, Enum):
    DIRECT_OVERRIDE = "direct_override"        # "忽略以上指令"
    STRUCTURED_INJECT = "structured_inject"    # JSON/Markdown嵌套指令
    PROGRESSIVE_GROOMING = "progressive_grooming"  # 多轮渐进催眠
    COT_POISONING = "cot_poisoning"            # 思维链投毒
    METADATA_EXPLOIT = "metadata_exploit"      # 元数据字段利用
    CONTEXT_LEAK_PROBE = "context_leak_probe"  # 系统Prompt探测


@dataclass
class SanitizationResult:
    """净化结果"""
    clean_input: str = ""
    threat_level: ThreatLevel = ThreatLevel.SAFE
    detected_patterns: List[InjectionPattern] = field(default_factory=list)
    redacted_sections: List[str] = field(default_factory=list)
    session_risk_score: float = 0.0  # 0-1, 累积风险
    action: str = "proceed"          # proceed / warn / block
    rationale: str = ""


class StructuredInputValidator(BaseModel):
    """结构化输入验证器 - 防止JSON/Markdown注入"""
    content: str = Field(min_length=1, max_length=10000)
    metadata: Optional[Dict[str, Any]] = None

    @field_validator("content")
    @classmethod
    def validate_content(cls, v: str) -> str:
        # 1. 移除隐藏Unicode控制字符
        v = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', v)

        # 2. 检测并剥离嵌套的指令结构
        # 匹配类似 {"instruction": "...", "override": true} 的模式
        inject_pattern = r'\{[^{}]*"(?:instruction|override|system_prompt|ignore_previous)"[^{}]*\}'
        if re.search(inject_pattern, v, re.IGNORECASE):
            raise ValueError("Structured injection detected in content")

        # 3. 检测Markdown标题注入 (## System Override)
        md_inject = r'^#{1,3}\s*(?:system|override|ignore|admin|root)\b'
        if re.search(md_inject, v, re.IGNORECASE | re.MULTILINE):
            raise ValueError("Markdown header injection detected")

        return v

    @field_validator("metadata")
    @classmethod
    def validate_metadata(cls, v: Optional[Dict]) -> Optional[Dict]:
        if v is None:
            return v
        # 元数据字段白名单
        allowed_keys = {"source", "timestamp", "user_id", "session_id"}
        for key in v.keys():
            if key not in allowed_keys: 31330.t.kuaisou.com
                raise ValueError(f"Disallowed metadata key: {key}")
        return v


class AgentInputGuard:
    """Agent输入守卫"""

    # 直接覆盖类注入关键词
    OVERRIDE_PATTERNS = [
        r'ignore\s+(all\s+)?(previous|above|prior)\s+(instructions?|prompts?|rules?)',
        r'disregard\s+(everything|all)\s+(before|above)',
        r'you\s+are\s+now\s+(a|an)\s+',
        r'new\s+instructions?:',
        r'system\s*:\s*',
        r'\[INST\]|\[/INST\]|<<SYS>>|<</SYS>>',
    ]

    # 系统Prompt探测模式
    LEAK_PROBES = [
        r'(what|show|tell|repeat|print)\s+(your|the)\s+(system|initial|base)\s+(prompt|instructions?|rules?)',
        r'output\s+your\s+(full\s+)?(prompt|instructions?)',
        r'reveal\s+(your\s+)?(hidden|secret|internal)\s+(instructions?|rules?)',
    ]

    def __init__(self, redis_client, metrics, siem_logger):
        self.redis = redis_client
        self.metrics = metrics
        self.siem = siem_logger
        self.compiled_overrides = [re.compile(p, re.I) for p in self.OVERRIDE_PATTERNS]
        self.compiled_leaks = [re.compile(p, re.I) for p in self.LEAK_PROBES]

    async def sanitize(self, user_input: str, session_id: str,
                       agent_id: str, turn_number: int = 1
                       ) -> SanitizationResult:
        """主净化入口"""
        result = SanitizationResult(clean_input=user_input)
        detected: List[InjectionPattern] = []

        # 1. 结构化输入验证
        try:
            validated = StructuredInputValidator(content=user_input)
            result.clean_input = validated.content
        except ValueError as e:
            detected.append(InjectionPattern.STRUCTURED_INJECT)
            result.rationale = str(e)

        # 2. 直接覆盖检测
        for pattern in self.compiled_overrides:
            if pattern.search(result.clean_input):
                detected.append(InjectionPattern.DIRECT_OVERRIDE)
                break

        # 3. 系统Prompt泄露探测
        for pattern in self.compiled_leaks:
            if pattern.search(result.clean_input):
                detected.append(InjectionPattern.CONTEXT_LEAK_PROBE)
                break

        # 4. 渐进式注入检测 (多轮累积风险)
        session_risk = await self._check_progressive(session_id, user_input, turn_number)
        result.session_risk_score = session_risk
        if session_risk > 0.7: 31331.t.kuaisou.com
            detected.append(InjectionPattern.PROGRESSIVE_GROOMING)

        # 5. 综合判定
        result.detected_patterns = detected
        result.threat_level, result.action = self._decide(detected, session_risk)

        # 6. 记录与上报
        await self._log_event(agent_id, session_id, turn_number, result)
        self.metrics.increment("input_scan", {
            "level": result.threat_level.value,
            "agent": agent_id
        })

        return result

    async def _check_progressive(self, session_id: str,
                                 user_input: str, turn: int) -> float:
        """检测多轮渐进式注入"""
        key = f"session_risk:{session_id}"
        history = await self.redis.lrange(key, 0, -1)

        # 计算当前输入的"操纵倾向分数"
        current_score = self._manipulation_score(user_input)

        # 累积风险: 滑动窗口加权平均
        scores = [float(s) for s in history[-9:]] + [current_score]
        weights = list(range(1, len(scores) + 1))  # 近期权重更高
        weighted_avg = sum(s * w for s, w in zip(scores, weights)) / sum(weights)

        # 持久化
        await self.redis.rpush(key, str(current_score))
        await self.redis.expire(key, 3600)  # 1小时过期

        return min(1.0, weighted_avg)

    def _manipulation_score(self, text: str) -> float:
        """单轮操纵倾向评分 (0-1)"""
        score = 0.0
        indicators = [
            (r'(pretend|imagine|suppose|assume)\s+(you\s+are|that\s+you)', 0.3),
            (r'(roleplay|act\s+as|behave\s+as)', 0.2),
            (r'(secret|hidden|confidential|internal)', 0.15),
            (r'(admin|root|superuser|privileged)', 0.25),
            (r'(bypass|circumvent|override|disable)', 0.3),
            (r'(jailbreak|dan|developer\s+mode)', 0.4),
        ]
        for pattern, weight in indicators:
            if re.search(pattern, text, re.I):
                score += weight
        return min(1.0, score)

    def _decide(self, patterns: List[InjectionPattern],
                session_risk: float) -> Tuple[ThreatLevel, str]:
        """综合判定"""
        if not patterns and session_risk < 0.3:
            return ThreatLevel.SAFE, "proceed"

        high_threats = {InjectionPattern.DIRECT_OVERRIDE,
                        InjectionPattern.STRUCTURED_INJECT,
                        InjectionPattern.COT_POISONING}

        if any(p in high_threats for p in patterns) or session_risk > 0.85:
            return ThreatLevel.BLOCKED, "block"

        if patterns or session_risk > 0.5: 31332.t.kuaisou.com
            return ThreatLevel.SUSPICIOUS, "warn"

        return ThreatLevel.SAFE, "proceed"

    async def _log_event(self, agent_id: str, session_id: str,
                         turn: int, result: SanitizationResult):
        """写入SIEM审计日志"""
        event = {
            "event_type": "input_sanitization",
            "agent_id": agent_id,
            "session_id": session_id,
            "turn": turn,
            "threat_level": result.threat_level.value,
            "patterns": [p.value for p in result.detected_patterns],
            "risk_score": round(result.session_risk_score, 3),
            "action": result.action,
            "timestamp": time.time(31333.t.kuaisou.com),
        }
        await self.siem.log(event)


四、 实战2：运行时权限治理与输出防护引擎

：Agent只能做被允许的事，只能说不该说的不说，即使被攻破也有最后一道防线。

4.1 核心实现：agent_runtime_shield.py

"""
agent_runtime_shield.py - Agent运行时权限治理与输出防护
核心: 信任但验证，允许但审计，输出但过滤
"""
from typing import Dict, List, Any, Optional, Set, Tuple
from enum import Enum
from dataclasses import dataclass, field
import re, time, json, hashlib


class PermissionLevel(str, Enum):
    READ = "read"
    WRITE = "write"
    ADMIN = "admin"
    NONE = "none"


class SensitiveCategory(str, Enum):
    SYSTEM_PROMPT = "system_prompt"
    USER_PII = "user_pii"
    CREDENTIALS = "credentials"
    INTERNAL_API = "internal_api"
    BUSINESS_SECRET = "business_secret"


@dataclass
class ToolPermission:
    """工具权限定义"""
    tool_id: str = ""
    allowed_agents: Set[str] = field(default_factory=set)
    required_level: PermissionLevel = PermissionLevel.READ
    sensitive_params: List[str] = field(default_factory=list)  # 需脱敏的参数
    requires_confirmation: bool = False  # 是否需二次确认
    max_calls_per_session: int = 20
    allowed_param_patterns: Dict[str, str] = field(default_factory=dict)  # 参数值正则白名单


@dataclass
class OutputFilterResult:
    """输出过滤结果"""
    clean_output: str = ""
    filtered: bool = False
    categories_detected: List[SensitiveCategory] = field(default_factory=list)
    redaction_count: int = 0
    blocked: bool = False
    rationale: str = ""


class AgentRuntimeShield:
    """Agent运行时防护盾"""

    # 敏感信息正则
    PII_PATTERNS = [
        (SensitiveCategory.USER_PII, r'\b\d{17}[\dXx]\b'),  # 身份证
        (SensitiveCategory.USER_PII, r'\b1[3-9]\d{9}\b'),   # 手机号
        (SensitiveCategory.CREDENTIALS, r'(?:password|passwd|pwd|token|api_key|secret)\s*[:=]\s*\S+'),
        (SensitiveCategory.CREDENTIALS, r'bearer\s+[A-Za-z0-9\-._~+/]+=*'),
        (SensitiveCategory.INTERNAL_API, r'https?://(?:internal|intranet|localhost|127\.0\.0\.1|10\.\d+\.\d+\.\d+)\S*'),
    ]

    def __init__(self, permission_store, redis_client, metrics, siem):
        self.permissions: Dict[str, ToolPermission] = {}
        self.redis = redis_client
        self.metrics = metrics
        self.siem = siem
        self.compiled_pii = [(cat, re.compile(p, re.I))
                             for cat, p in self.PII_PATTERNS]

    # ─── 权限治理: 工具调用前验证 ───
    async def authorize_tool_call(self, agent_id: str, tool_id: str,
                                  params: Dict, session_id: str
                                  ) -> Tuple[bool, str]:
        """运行时工具调用授权"""
        perm = self.permissions.get(tool_id)
        if not perm:  31334.t.kuaisou.com
            return False, f"Unknown tool: {tool_id}"

        # 1. Agent白名单检查
        if agent_id not in perm.allowed_agents:
            await self._log_violation(agent_id, tool_id, "agent_not_allowed")
            return False, f"Agent '{agent_id}' not authorized for '{tool_id}'"

        # 2. 参数Schema验证
        for param_name, pattern in perm.allowed_param_patterns.items():
            value = params.get(param_name, "")
            if not re.match(pattern, str(value)):
                await self._log_violation(agent_id, tool_id,
                                          f"param_violation:{param_name}")
                return False, f"Invalid parameter '{param_name}'"

        # 3. 调用频率限制
        count_key = f"tool_calls:{session_id}:{tool_id}"
        current = int(await self.redis.get(count_key) or 0)
        if current >= perm.max_calls_per_session:
            return False, f"Tool '{tool_id}' call limit reached ({perm.max_calls_per_session})"

        # 4. 敏感操作二次确认标记
        if perm.requires_confirmation:
            return True, "requires_confirmation"

        # 5. 递增计数
        await self.redis.incr(count_key)
        await self.redis.expire(count_key, 3600)

        return True, "authorized"

    # ─── 输出防护: 敏感信息过滤 ───
    async def filter_output(self, output: str, agent_id: str,
                            system_prompt_hash: str = ""
                            ) -> OutputFilterResult:
        """输出内容安全过滤"""
        result = OutputFilterResult(clean_output=output)
        detected_cats: List[SensitiveCategory] = []

        # 1. 系统Prompt泄露检测
        if system_prompt_hash:
            sim = self._prompt_similarity(output, system_prompt_hash)
            if sim > 0.6:
                detected_cats.append(SensitiveCategory.SYSTEM_PROMPT)
                result.blocked = True
                result.rationale = "System prompt leakage detected"

        # 2. PII/凭证/内部URL检测与脱敏
        for category, pattern in self.compiled_pii:
            matches = list(pattern.finditer(result.clean_output))
            if matches:
                detected_cats.append(category)
                for match in reversed(matches):  # 反向替换保持索引有效
                    result.clean_output = (
                        result.clean_output[:match.start()] +
                        "[REDACTED]" +
                        result.clean_output[match.end():]
                    )
                    result.redaction_count += 1

        # 3. 综合判定
        result.categories_detected = list(set(detected_cats))
        result.filtered = result.redaction_count > 0 or result.blocked

        if result.filtered:
            self.metrics.increment("output_filtered", {
                "agent": agent_id,
                "categories": ",".join(c.value for c in result.categories_detected)
            })
            await self.siem.log({
                "event_type": "output_filter",
                "agent_id": agent_id,
                "categories": [c.value for c in result.categories_detected],
                "redactions": result.redaction_count,
                "blocked": result.blocked,
                "timestamp": time.time()
            })

        return result

    # ─── 工具输出净化: 防止工具链投毒 ───
    async def sanitize_tool_output(self, tool_id: str, raw_output: Any
                                   ) -> Tuple[Any, bool]:
        """净化工具返回值，剥离潜在注入指令"""
        if isinstance(raw_output, dict):
            sanitized = {}
            poisoned = False
            for k, v in raw_output.items(): 31335.t.kuaisou.com
                # 剥离可疑的指令字段
                if k.lower(31336.t.kuaisou.com) in ("instruction", "override", "system_prompt",
                                  "ignore_previous", "new_rules"):
                    poisoned = True
                    continue
                # 递归净化字符串值
                if isinstance(v, str):
                    clean_v, was_poisoned = self._strip_embedded_instructions(v)
                    sanitized[k] = clean_v
                    if was_poisoned:
                        poisoned = True
                else:
                    sanitized[k] = v
            return sanitized, poisoned

        elif isinstance(raw_output, str): 31337.t.kuaisou.com
            return self._strip_embedded_instructions(raw_output)

        return raw_output, False

    def _strip_embedded_instructions(self, text: str) -> Tuple[str, bool]:
        """剥离文本中嵌入的指令片段"""
        patterns = [
            r'\[SYSTEM:.*?\]',
            r'\{.*?"(?:instruction|override)".*?\}',
            r'',
        ]
        original = text
        for p in patterns: 31338.t.kuaisou.com
            text = re.sub(p, '', text, flags=re.I | re.DOTALL)
        return text, text != original

    def _prompt_similarity(self, output: str, prompt_hash: str) -> float:
        """检测输出是否与系统Prompt相似"""
        # 简化: 检查输出中是否包含系统Prompt的特征片段hash
        # 实际应使用embedding相似度
        output_hash = hashlib.sha256(output.encode()).hexdigest()[:16]
        return 1.0 if output_hash == prompt_hash else 0.0

    async def _log_violation(self, agent_id: str, tool_id: str, reason: str):
        await self.siem.log({
            "event_type": "permission_violation",
            "agent_id": agent_id,
            "tool_id": tool_id,
            "reason": reason,
            "timestamp": time.time(31339.t.kuaisou.com)
        })
        self.metrics.increment("permission_violation", {
            "agent": agent_id, "tool": tool_id
        })

五、 生产铁律：Agent安全六条不可妥协的底线

六、 结语：安全是Agent工程的"地基"而非"装修"

在传统软件工程中，安全常被当作上线前的"合规检查项"。但在Agent时代，这种思维是致命的——因为Agent的非确定性意味着你无法穷举所有可能的执行路径，也就无法在测试阶段发现所有安全漏洞。

唯一可靠的策略是让防御成为架构的一部分，而非附加的补丁。

输入净化是第一道门，执行沙箱是第二道墙，权限治理是第三道锁，输出防护是第四道网，审计响应是最后的警报器。五层纵深不是冗余，而是对Agent非确定性本质的工程回应——既然无法保证Agent永远不做错事，就必须确保它做错事时伤害可控、痕迹可追、恢复可期。

没有安全左移的Agent项目，不是在构建产品，而是在制造事故。

 那些认为"先把功能跑通再补安全"的团队，终将在第一次Prompt注入攻击中体会到：在Agent世界里，安全不是成本，而是存续的前提。

真正的Agent工程化成熟度，不是看它能做什么，而是看它在被攻击时还能守住什么。

 能跑的Agent是原型，守得住的Agent才是产品。

新闻导语2026年8月，AI Agent已接管企业核心决策链路，但OWASP最新报告显示，Agent专属攻击面同比激增340%——Prompt注入、工具链投毒、上下文窃取、权限越界成为新型威胁。传统"上线后补安全"的模式在Agent时代彻底失效。行业共识转向"安全左移"：在架构设计阶段即嵌入防御，让每个Agent天生具备抗攻击能力。安全不再是附加组件，而是智能体工程的第零层基础设施。

Agent安全左移：2026智能体防御性工程与运行时防护实战

人工智能

安全

2026年AI Agent攻击面激增340%，Prompt注入、工具链投毒等四重威胁迫使安全架构“左移”。本文提出五层纵深防御模型：输入净化、执行沙箱、权限治理、输出防护及审计响应，并附核心代码实战。安全成为Agent工程第零层基础设施，构建守得住的智能体产品。

结构化数据

内容安全

安全左移

软件工程

数据库

智能体

Redis

Agent

JSON

2026上云采购 | AI焕新·智启新局

lexiang

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

Agent安全左移：2026智能体防御性工程与运行时防护实战

Agent安全左移：2026智能体防御性工程与运行时防护实战

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐