[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M71R62PC0RMQGPBJ0Y6EJBJY":3,"skill-same:01M71R62PC0RMQGPBJ0Y6EJBJY":68},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":22,"publishedAt":43,"linkOnly":44,"markdownContent":45,"markdownBody":46,"frontMatter":47,"refName":48,"commitSha":49,"skillDirectory":50,"forksCount":13,"repositoryHtmlUrl":51,"repositoryHomepageUrl":6,"ownerHtmlUrl":52,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":53,"install":54,"resources":67},"01M71R62PC0RMQGPBJ0Y6EJBJY","agent-governance",null,"Patterns and techniques for adding governance, safety, and trust controls to AI agent systems. Use this skill when:\n- Building AI agents that call external tools (APIs, databases, file systems)\n- Implementing policy-based access controls for agent tool usage\n- Adding semantic intent classification to detect dangerous prompts\n- Creating trust scoring systems for multi-agent workflows\n- Building audit trails for agent actions and decisions\n- Enforcing rate limits, content filters, or tool restrictions on agents\n- Working with any agent framework (PydanticAI, CrewAI, OpenAI Agents, LangChain, AutoGen)","javiertarazon\u002Fide-agente-free-jt7-","javiertarazon","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F153141207?v=4","01M71R52TB3S9HXKH6WSNT8A7V","01M71R52VG5KS2DKDDH4GDQ30A",0,"MIT","https:\u002F\u002Fgithub.com\u002Fjaviertarazon\u002Fide-agente-free-jt7-\u002Fblob\u002Frelease\u002Fv4.2.11-panel-pro\u002F.github\u002Fskills\u002Fagent-governance\u002FSKILL.md",[17],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42],"governance","agent governance","Safety","rate","audit","intent","limits","scoring","ai agents","when","workflows","access","ai agent","agent framework","filters","implementing","external tools","actions","agent tool","databases","2026-11-10 13:02:02",false,"---\nname: agent-governance\ndescription: |\n  Patterns and techniques for adding governance, safety, and trust controls to AI agent systems. Use this skill when:\n  - Building AI agents that call external tools (APIs, databases, file systems)\n  - Implementing policy-based access controls for agent tool usage\n  - Adding semantic intent classification to detect dangerous prompts\n  - Creating trust scoring systems for multi-agent workflows\n  - Building audit trails for agent actions and decisions\n  - Enforcing rate limits, content filters, or tool restrictions on agents\n  - Working with any agent framework (PydanticAI, CrewAI, OpenAI Agents, LangChain, AutoGen)\n---\n\n# Agent Governance Patterns\n\nPatterns for adding safety, trust, and policy enforcement to AI agent systems.\n\n## Overview\n\nGovernance patterns ensure AI agents operate within defined boundaries — controlling which tools they can call, what content they can process, how much they can do, and maintaining accountability through audit trails.\n\n```\nUser Request → Intent Classification → Policy Check → Tool Execution → Audit Log\n                     ↓                      ↓               ↓\n              Threat Detection         Allow\u002FDeny      Trust Update\n```\n\n## When to Use\n\n- **Agents with tool access**: Any agent that calls external tools (APIs, databases, shell commands)\n- **Multi-agent systems**: Agents delegating to other agents need trust boundaries\n- **Production deployments**: Compliance, audit, and safety requirements\n- **Sensitive operations**: Financial transactions, data access, infrastructure management\n\n---\n\n## Pattern 1: Governance Policy\n\nDefine what an agent is allowed to do as a composable, serializable policy object.\n\n```python\nfrom dataclasses import dataclass, field\nfrom enum import Enum\nfrom typing import Optional\nimport re\n\nclass PolicyAction(Enum):\n    ALLOW = \"allow\"\n    DENY = \"deny\"\n    REVIEW = \"review\"  # flag for human review\n\n@dataclass\nclass GovernancePolicy:\n    \"\"\"Declarative policy controlling agent behavior.\"\"\"\n    name: str\n    allowed_tools: list[str] = field(default_factory=list)       # allowlist\n    blocked_tools: list[str] = field(default_factory=list)       # blocklist\n    blocked_patterns: list[str] = field(default_factory=list)    # content filters\n    max_calls_per_request: int = 100                             # rate limit\n    require_human_approval: list[str] = field(default_factory=list)  # tools needing approval\n\n    def check_tool(self, tool_name: str) -> PolicyAction:\n        \"\"\"Check if a tool is allowed by this policy.\"\"\"\n        if tool_name in self.blocked_tools:\n            return PolicyAction.DENY\n        if tool_name in self.require_human_approval:\n            return PolicyAction.REVIEW\n        if self.allowed_tools and tool_name not in self.allowed_tools:\n            return PolicyAction.DENY\n        return PolicyAction.ALLOW\n\n    def check_content(self, content: str) -> Optional[str]:\n        \"\"\"Check content against blocked patterns. Returns matched pattern or None.\"\"\"\n        for pattern in self.blocked_patterns:\n            if re.search(pattern, content, re.IGNORECASE):\n                return pattern\n        return None\n```\n\n### Policy Composition\n\nCombine multiple policies (e.g., org-wide + team + agent-specific):\n\n```python\ndef compose_policies(*policies: GovernancePolicy) -> GovernancePolicy:\n    \"\"\"Merge policies with most-restrictive-wins semantics.\"\"\"\n    combined = GovernancePolicy(name=\"composed\")\n\n    for policy in policies:\n        combined.blocked_tools.extend(policy.blocked_tools)\n        combined.blocked_patterns.extend(policy.blocked_patterns)\n        combined.require_human_approval.extend(policy.require_human_approval)\n        combined.max_calls_per_request = min(\n            combined.max_calls_per_request,\n            policy.max_calls_per_request\n        )\n        if policy.allowed_tools:\n            if combined.allowed_tools:\n                combined.allowed_tools = [\n                    t for t in combined.allowed_tools if t in policy.allowed_tools\n                ]\n            else:\n                combined.allowed_tools = list(policy.allowed_tools)\n\n    return combined\n\n\n# Usage: layer policies from broad to specific\norg_policy = GovernancePolicy(\n    name=\"org-wide\",\n    blocked_tools=[\"shell_exec\", \"delete_database\"],\n    blocked_patterns=[r\"(?i)(api[_-]?key|secret|password)\\s*[:=]\"],\n    max_calls_per_request=50\n)\nteam_policy = GovernancePolicy(\n    name=\"data-team\",\n    allowed_tools=[\"query_db\", \"read_file\", \"write_report\"],\n    require_human_approval=[\"write_report\"]\n)\nagent_policy = compose_policies(org_policy, team_policy)\n```\n\n### Policy as YAML\n\nStore policies as configuration, not code:\n\n```yaml\n# governance-policy.yaml\nname: production-agent\nallowed_tools:\n  - search_documents\n  - query_database\n  - send_email\nblocked_tools:\n  - shell_exec\n  - delete_record\nblocked_patterns:\n  - \"(?i)(api[_-]?key|secret|password)\\\\s*[:=]\"\n  - \"(?i)(drop|truncate|delete from)\\\\s+\\\\w+\"\nmax_calls_per_request: 25\nrequire_human_approval:\n  - send_email\n```\n\n```python\nimport yaml\n\ndef load_policy(path: str) -> GovernancePolicy:\n    with open(path) as f:\n        data = yaml.safe_load(f)\n    return GovernancePolicy(**data)\n```\n\n---\n\n## Pattern 2: Semantic Intent Classification\n\nDetect dangerous intent in prompts before they reach the agent, using pattern-based signals.\n\n```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass IntentSignal:\n    category: str       # e.g., \"data_exfiltration\", \"privilege_escalation\"\n    confidence: float   # 0.0 to 1.0\n    evidence: str       # what triggered the detection\n\n# Weighted signal patterns for threat detection\nTHREAT_SIGNALS = [\n    # Data exfiltration\n    (r\"(?i)send\\s+(all|every|entire)\\s+\\w+\\s+to\\s+\", \"data_exfiltration\", 0.8),\n    (r\"(?i)export\\s+.*\\s+to\\s+(external|outside|third.?party)\", \"data_exfiltration\", 0.9),\n    (r\"(?i)curl\\s+.*\\s+-d\\s+\", \"data_exfiltration\", 0.7),\n\n    # Privilege escalation\n    (r\"(?i)(sudo|as\\s+root|admin\\s+access)\", \"privilege_escalation\", 0.8),\n    (r\"(?i)chmod\\s+777\", \"privilege_escalation\", 0.9),\n\n    # System modification\n    (r\"(?i)(rm\\s+-rf|del\\s+\u002F[sq]|format\\s+c:)\", \"system_destruction\", 0.95),\n    (r\"(?i)(drop\\s+database|truncate\\s+table)\", \"system_destruction\", 0.9),\n\n    # Prompt injection\n    (r\"(?i)ignore\\s+(previous|above|all)\\s+(instructions?|rules?)\", \"prompt_injection\", 0.9),\n    (r\"(?i)you\\s+are\\s+now\\s+(a|an)\\s+\", \"prompt_injection\", 0.7),\n]\n\ndef classify_intent(content: str) -> list[IntentSignal]:\n    \"\"\"Classify content for threat signals.\"\"\"\n    signals = []\n    for pattern, category, weight in THREAT_SIGNALS:\n        match = re.search(pattern, content)\n        if match:\n            signals.append(IntentSignal(\n                category=category,\n                confidence=weight,\n                evidence=match.group()\n            ))\n    return signals\n\ndef is_safe(content: str, threshold: float = 0.7) -> bool:\n    \"\"\"Quick check: is the content safe above the given threshold?\"\"\"\n    signals = classify_intent(content)\n    return not any(s.confidence >= threshold for s in signals)\n```\n\n**Key insight**: Intent classification happens *before* tool execution, acting as a pre-flight safety check. This is fundamentally different from output guardrails which only check *after* generation.\n\n---\n\n## Pattern 3: Tool-Level Governance Decorator\n\nWrap individual tool functions with governance checks:\n\n```python\nimport functools\nimport time\nfrom collections import defaultdict\n\n_call_counters: dict[str, int] = defaultdict(int)\n\ndef govern(policy: GovernancePolicy, audit_trail=None):\n    \"\"\"Decorator that enforces governance policy on a tool function.\"\"\"\n    def decorator(func):\n        @functools.wraps(func)\n        async def wrapper(*args, **kwargs):\n            tool_name = func.__name__\n\n            # 1. Check tool allowlist\u002Fblocklist\n            action = policy.check_tool(tool_name)\n            if action == PolicyAction.DENY:\n                raise PermissionError(f\"Policy '{policy.name}' blocks tool '{tool_name}'\")\n            if action == PolicyAction.REVIEW:\n                raise PermissionError(f\"Tool '{tool_name}' requires human approval\")\n\n            # 2. Check rate limit\n            _call_counters[policy.name] += 1\n            if _call_counters[policy.name] > policy.max_calls_per_request:\n                raise PermissionError(f\"Rate limit exceeded: {policy.max_calls_per_request} calls\")\n\n            # 3. Check content in arguments\n            for arg in list(args) + list(kwargs.values()):\n                if isinstance(arg, str):\n                    matched = policy.check_content(arg)\n                    if matched:\n                        raise PermissionError(f\"Blocked pattern detected: {matched}\")\n\n            # 4. Execute and audit\n            start = time.monotonic()\n            try:\n                result = await func(*args, **kwargs)\n                if audit_trail is not None:\n                    audit_trail.append({\n                        \"tool\": tool_name,\n                        \"action\": \"allowed\",\n                        \"duration_ms\": (time.monotonic() - start) * 1000,\n                        \"timestamp\": time.time()\n                    })\n                return result\n            except Exception as e:\n                if audit_trail is not None:\n                    audit_trail.append({\n                        \"tool\": tool_name,\n                        \"action\": \"error\",\n                        \"error\": str(e),\n                        \"timestamp\": time.time()\n                    })\n                raise\n\n        return wrapper\n    return decorator\n\n\n# Usage with any agent framework\naudit_log = []\npolicy = GovernancePolicy(\n    name=\"search-agent\",\n    allowed_tools=[\"search\", \"summarize\"],\n    blocked_patterns=[r\"(?i)password\"],\n    max_calls_per_request=10\n)\n\n@govern(policy, audit_trail=audit_log)\nasync def search(query: str) -> str:\n    \"\"\"Search documents — governed by policy.\"\"\"\n    return f\"Results for: {query}\"\n\n# Passes: search(\"latest quarterly report\")\n# Blocked: search(\"show me the admin password\")\n```\n\n---\n\n## Pattern 4: Trust Scoring\n\nTrack agent reliability over time with decay-based trust scores:\n\n```python\nfrom dataclasses import dataclass, field\nimport math\nimport time\n\n@dataclass\nclass TrustScore:\n    \"\"\"Trust score with temporal decay.\"\"\"\n    score: float = 0.5          # 0.0 (untrusted) to 1.0 (fully trusted)\n    successes: int = 0\n    failures: int = 0\n    last_updated: float = field(default_factory=time.time)\n\n    def record_success(self, reward: float = 0.05):\n        self.successes += 1\n        self.score = min(1.0, self.score + reward * (1 - self.score))\n        self.last_updated = time.time()\n\n    def record_failure(self, penalty: float = 0.15):\n        self.failures += 1\n        self.score = max(0.0, self.score - penalty * self.score)\n        self.last_updated = time.time()\n\n    def current(self, decay_rate: float = 0.001) -> float:\n        \"\"\"Get score with temporal decay — trust erodes without activity.\"\"\"\n        elapsed = time.time() - self.last_updated\n        decay = math.exp(-decay_rate * elapsed)\n        return self.score * decay\n\n    @property\n    def reliability(self) -> float:\n        total = self.successes + self.failures\n        return self.successes \u002F total if total > 0 else 0.0\n\n\n# Usage in multi-agent systems\ntrust = TrustScore()\n\n# Agent completes tasks successfully\ntrust.record_success()  # 0.525\ntrust.record_success()  # 0.549\n\n# Agent makes an error\ntrust.record_failure()  # 0.467\n\n# Gate sensitive operations on trust\nif trust.current() >= 0.7:\n    # Allow autonomous operation\n    pass\nelif trust.current() >= 0.4:\n    # Allow with human oversight\n    pass\nelse:\n    # Deny or require explicit approval\n    pass\n```\n\n**Multi-agent trust**: In systems where agents delegate to other agents, each agent maintains trust scores for its delegates:\n\n```python\nclass AgentTrustRegistry:\n    def __init__(self):\n        self.scores: dict[str, TrustScore] = {}\n\n    def get_trust(self, agent_id: str) -> TrustScore:\n        if agent_id not in self.scores:\n            self.scores[agent_id] = TrustScore()\n        return self.scores[agent_id]\n\n    def most_trusted(self, agents: list[str]) -> str:\n        return max(agents, key=lambda a: self.get_trust(a).current())\n\n    def meets_threshold(self, agent_id: str, threshold: float) -> bool:\n        return self.get_trust(agent_id).current() >= threshold\n```\n\n---\n\n## Pattern 5: Audit Trail\n\nAppend-only audit log for all agent actions — critical for compliance and debugging:\n\n```python\nfrom dataclasses import dataclass, field\nimport json\nimport time\n\n@dataclass\nclass AuditEntry:\n    timestamp: float\n    agent_id: str\n    tool_name: str\n    action: str           # \"allowed\", \"denied\", \"error\"\n    policy_name: str\n    details: dict = field(default_factory=dict)\n\nclass AuditTrail:\n    \"\"\"Append-only audit trail for agent governance events.\"\"\"\n    def __init__(self):\n        self._entries: list[AuditEntry] = []\n\n    def log(self, agent_id: str, tool_name: str, action: str,\n            policy_name: str, **details):\n        self._entries.append(AuditEntry(\n            timestamp=time.time(),\n            agent_id=agent_id,\n            tool_name=tool_name,\n            action=action,\n            policy_name=policy_name,\n            details=details\n        ))\n\n    def denied(self) -> list[AuditEntry]:\n        \"\"\"Get all denied actions — useful for security review.\"\"\"\n        return [e for e in self._entries if e.action == \"denied\"]\n\n    def by_agent(self, agent_id: str) -> list[AuditEntry]:\n        return [e for e in self._entries if e.agent_id == agent_id]\n\n    def export_jsonl(self, path: str):\n        \"\"\"Export as JSON Lines for log aggregation systems.\"\"\"\n        with open(path, \"w\") as f:\n            for entry in self._entries:\n                f.write(json.dumps({\n                    \"timestamp\": entry.timestamp,\n                    \"agent_id\": entry.agent_id,\n                    \"tool\": entry.tool_name,\n                    \"action\": entry.action,\n                    \"policy\": entry.policy_name,\n                    **entry.details\n                }) + \"\\n\")\n```\n\n---\n\n## Pattern 6: Framework Integration\n\n### PydanticAI\n\n```python\nfrom pydantic_ai import Agent\n\npolicy = GovernancePolicy(\n    name=\"support-bot\",\n    allowed_tools=[\"search_docs\", \"create_ticket\"],\n    blocked_patterns=[r\"(?i)(ssn|social\\s+security|credit\\s+card)\"],\n    max_calls_per_request=20\n)\n\nagent = Agent(\"openai:gpt-4o\", system_prompt=\"You are a support assistant.\")\n\n@agent.tool\n@govern(policy)\nasync def search_docs(ctx, query: str) -> str:\n    \"\"\"Search knowledge base — governed.\"\"\"\n    return await kb.search(query)\n\n@agent.tool\n@govern(policy)\nasync def create_ticket(ctx, title: str, body: str) -> str:\n    \"\"\"Create support ticket — governed.\"\"\"\n    return await tickets.create(title=title, body=body)\n```\n\n### CrewAI\n\n```python\nfrom crewai import Agent, Task, Crew\n\npolicy = GovernancePolicy(\n    name=\"research-crew\",\n    allowed_tools=[\"search\", \"analyze\"],\n    max_calls_per_request=30\n)\n\n# Apply governance at the crew level\ndef governed_crew_run(crew: Crew, policy: GovernancePolicy):\n    \"\"\"Wrap crew execution with governance checks.\"\"\"\n    audit = AuditTrail()\n    for agent in crew.agents:\n        for tool in agent.tools:\n            original = tool.func\n            tool.func = govern(policy, audit_trail=audit)(original)\n    result = crew.kickoff()\n    return result, audit\n```\n\n### OpenAI Agents SDK\n\n```python\nfrom agents import Agent, function_tool\n\npolicy = GovernancePolicy(\n    name=\"coding-agent\",\n    allowed_tools=[\"read_file\", \"write_file\", \"run_tests\"],\n    blocked_tools=[\"shell_exec\"],\n    max_calls_per_request=50\n)\n\n@function_tool\n@govern(policy)\nasync def read_file(path: str) -> str:\n    \"\"\"Read file contents — governed.\"\"\"\n    import os\n    safe_path = os.path.realpath(path)\n    if not safe_path.startswith(os.path.realpath(\".\")):\n        raise ValueError(\"Path traversal blocked by governance\")\n    with open(safe_path) as f:\n        return f.read()\n```\n\n---\n\n## Governance Levels\n\nMatch governance strictness to risk level:\n\n| Level | Controls | Use Case |\n|-------|----------|----------|\n| **Open** | Audit only, no restrictions | Internal dev\u002Ftesting |\n| **Standard** | Tool allowlist + content filters | General production agents |\n| **Strict** | All controls + human approval for sensitive ops | Financial, healthcare, legal |\n| **Locked** | Allowlist only, no dynamic tools, full audit | Compliance-critical systems |\n\n---\n\n## Best Practices\n\n| Practice | Rationale |\n|----------|-----------|\n| **Policy as configuration** | Store policies in YAML\u002FJSON, not hardcoded — enables change without deploys |\n| **Most-restrictive-wins** | When composing policies, deny always overrides allow |\n| **Pre-flight intent check** | Classify intent *before* tool execution, not after |\n| **Trust decay** | Trust scores should decay over time — require ongoing good behavior |\n| **Append-only audit** | Never modify or delete audit entries — immutability enables compliance |\n| **Fail closed** | If governance check errors, deny the action rather than allowing it |\n| **Separate policy from logic** | Governance enforcement should be independent of agent business logic |\n\n---\n\n## Quick Start Checklist\n\n```markdown\n## Agent Governance Implementation Checklist\n\n### Setup\n- [ ] Define governance policy (allowed tools, blocked patterns, rate limits)\n- [ ] Choose governance level (open\u002Fstandard\u002Fstrict\u002Flocked)\n- [ ] Set up audit trail storage\n\n### Implementation\n- [ ] Add @govern decorator to all tool functions\n- [ ] Add intent classification to user input processing\n- [ ] Implement trust scoring for multi-agent interactions\n- [ ] Wire up audit trail export\n\n### Validation\n- [ ] Test that blocked tools are properly denied\n- [ ] Test that content filters catch sensitive patterns\n- [ ] Test rate limiting behavior\n- [ ] Verify audit trail captures all events\n- [ ] Test policy composition (most-restrictive-wins)\n```\n\n---\n\n## Related Resources\n\n- [Agent-OS Governance Engine](https:\u002F\u002Fgithub.com\u002Fimran-siddique\u002Fagent-os) — Full governance framework\n- [AgentMesh Integrations](https:\u002F\u002Fgithub.com\u002Fimran-siddique\u002Fagentmesh-integrations) — Framework-specific packages\n- [OWASP Top 10 for LLM Applications](https:\u002F\u002Fowasp.org\u002Fwww-project-top-10-for-large-language-model-applications\u002F)\n","# Agent Governance Patterns\n\nPatterns for adding safety, trust, and policy enforcement to AI agent systems.\n\n## Overview\n\nGovernance patterns ensure AI agents operate within defined boundaries — controlling which tools they can call, what content they can process, how much they can do, and maintaining accountability through audit trails.\n\n```\nUser Request → Intent Classification → Policy Check → Tool Execution → Audit Log\n                     ↓                      ↓               ↓\n              Threat Detection         Allow\u002FDeny      Trust Update\n```\n\n## When to Use\n\n- **Agents with tool access**: Any agent that calls external tools (APIs, databases, shell commands)\n- **Multi-agent systems**: Agents delegating to other agents need trust boundaries\n- **Production deployments**: Compliance, audit, and safety requirements\n- **Sensitive operations**: Financial transactions, data access, infrastructure management\n\n---\n\n## Pattern 1: Governance Policy\n\nDefine what an agent is allowed to do as a composable, serializable policy object.\n\n```python\nfrom dataclasses import dataclass, field\nfrom enum import Enum\nfrom typing import Optional\nimport re\n\nclass PolicyAction(Enum):\n    ALLOW = \"allow\"\n    DENY = \"deny\"\n    REVIEW = \"review\"  # flag for human review\n\n@dataclass\nclass GovernancePolicy:\n    \"\"\"Declarative policy controlling agent behavior.\"\"\"\n    name: str\n    allowed_tools: list[str] = field(default_factory=list)       # allowlist\n    blocked_tools: list[str] = field(default_factory=list)       # blocklist\n    blocked_patterns: list[str] = field(default_factory=list)    # content filters\n    max_calls_per_request: int = 100                             # rate limit\n    require_human_approval: list[str] = field(default_factory=list)  # tools needing approval\n\n    def check_tool(self, tool_name: str) -> PolicyAction:\n        \"\"\"Check if a tool is allowed by this policy.\"\"\"\n        if tool_name in self.blocked_tools:\n            return PolicyAction.DENY\n        if tool_name in self.require_human_approval:\n            return PolicyAction.REVIEW\n        if self.allowed_tools and tool_name not in self.allowed_tools:\n            return PolicyAction.DENY\n        return PolicyAction.ALLOW\n\n    def check_content(self, content: str) -> Optional[str]:\n        \"\"\"Check content against blocked patterns. Returns matched pattern or None.\"\"\"\n        for pattern in self.blocked_patterns:\n            if re.search(pattern, content, re.IGNORECASE):\n                return pattern\n        return None\n```\n\n### Policy Composition\n\nCombine multiple policies (e.g., org-wide + team + agent-specific):\n\n```python\ndef compose_policies(*policies: GovernancePolicy) -> GovernancePolicy:\n    \"\"\"Merge policies with most-restrictive-wins semantics.\"\"\"\n    combined = GovernancePolicy(name=\"composed\")\n\n    for policy in policies:\n        combined.blocked_tools.extend(policy.blocked_tools)\n        combined.blocked_patterns.extend(policy.blocked_patterns)\n        combined.require_human_approval.extend(policy.require_human_approval)\n        combined.max_calls_per_request = min(\n            combined.max_calls_per_request,\n            policy.max_calls_per_request\n        )\n        if policy.allowed_tools:\n            if combined.allowed_tools:\n                combined.allowed_tools = [\n                    t for t in combined.allowed_tools if t in policy.allowed_tools\n                ]\n            else:\n                combined.allowed_tools = list(policy.allowed_tools)\n\n    return combined\n\n\n# Usage: layer policies from broad to specific\norg_policy = GovernancePolicy(\n    name=\"org-wide\",\n    blocked_tools=[\"shell_exec\", \"delete_database\"],\n    blocked_patterns=[r\"(?i)(api[_-]?key|secret|password)\\s*[:=]\"],\n    max_calls_per_request=50\n)\nteam_policy = GovernancePolicy(\n    name=\"data-team\",\n    allowed_tools=[\"query_db\", \"read_file\", \"write_report\"],\n    require_human_approval=[\"write_report\"]\n)\nagent_policy = compose_policies(org_policy, team_policy)\n```\n\n### Policy as YAML\n\nStore policies as configuration, not code:\n\n```yaml\n# governance-policy.yaml\nname: production-agent\nallowed_tools:\n  - search_documents\n  - query_database\n  - send_email\nblocked_tools:\n  - shell_exec\n  - delete_record\nblocked_patterns:\n  - \"(?i)(api[_-]?key|secret|password)\\\\s*[:=]\"\n  - \"(?i)(drop|truncate|delete from)\\\\s+\\\\w+\"\nmax_calls_per_request: 25\nrequire_human_approval:\n  - send_email\n```\n\n```python\nimport yaml\n\ndef load_policy(path: str) -> GovernancePolicy:\n    with open(path) as f:\n        data = yaml.safe_load(f)\n    return GovernancePolicy(**data)\n```\n\n---\n\n## Pattern 2: Semantic Intent Classification\n\nDetect dangerous intent in prompts before they reach the agent, using pattern-based signals.\n\n```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass IntentSignal:\n    category: str       # e.g., \"data_exfiltration\", \"privilege_escalation\"\n    confidence: float   # 0.0 to 1.0\n    evidence: str       # what triggered the detection\n\n# Weighted signal patterns for threat detection\nTHREAT_SIGNALS = [\n    # Data exfiltration\n    (r\"(?i)send\\s+(all|every|entire)\\s+\\w+\\s+to\\s+\", \"data_exfiltration\", 0.8),\n    (r\"(?i)export\\s+.*\\s+to\\s+(external|outside|third.?party)\", \"data_exfiltration\", 0.9),\n    (r\"(?i)curl\\s+.*\\s+-d\\s+\", \"data_exfiltration\", 0.7),\n\n    # Privilege escalation\n    (r\"(?i)(sudo|as\\s+root|admin\\s+access)\", \"privilege_escalation\", 0.8),\n    (r\"(?i)chmod\\s+777\", \"privilege_escalation\", 0.9),\n\n    # System modification\n    (r\"(?i)(rm\\s+-rf|del\\s+\u002F[sq]|format\\s+c:)\", \"system_destruction\", 0.95),\n    (r\"(?i)(drop\\s+database|truncate\\s+table)\", \"system_destruction\", 0.9),\n\n    # Prompt injection\n    (r\"(?i)ignore\\s+(previous|above|all)\\s+(instructions?|rules?)\", \"prompt_injection\", 0.9),\n    (r\"(?i)you\\s+are\\s+now\\s+(a|an)\\s+\", \"prompt_injection\", 0.7),\n]\n\ndef classify_intent(content: str) -> list[IntentSignal]:\n    \"\"\"Classify content for threat signals.\"\"\"\n    signals = []\n    for pattern, category, weight in THREAT_SIGNALS:\n        match = re.search(pattern, content)\n        if match:\n            signals.append(IntentSignal(\n                category=category,\n                confidence=weight,\n                evidence=match.group()\n            ))\n    return signals\n\ndef is_safe(content: str, threshold: float = 0.7) -> bool:\n    \"\"\"Quick check: is the content safe above the given threshold?\"\"\"\n    signals = classify_intent(content)\n    return not any(s.confidence >= threshold for s in signals)\n```\n\n**Key insight**: Intent classification happens *before* tool execution, acting as a pre-flight safety check. This is fundamentally different from output guardrails which only check *after* generation.\n\n---\n\n## Pattern 3: Tool-Level Governance Decorator\n\nWrap individual tool functions with governance checks:\n\n```python\nimport functools\nimport time\nfrom collections import defaultdict\n\n_call_counters: dict[str, int] = defaultdict(int)\n\ndef govern(policy: GovernancePolicy, audit_trail=None):\n    \"\"\"Decorator that enforces governance policy on a tool function.\"\"\"\n    def decorator(func):\n        @functools.wraps(func)\n        async def wrapper(*args, **kwargs):\n            tool_name = func.__name__\n\n            # 1. Check tool allowlist\u002Fblocklist\n            action = policy.check_tool(tool_name)\n            if action == PolicyAction.DENY:\n                raise PermissionError(f\"Policy '{policy.name}' blocks tool '{tool_name}'\")\n            if action == PolicyAction.REVIEW:\n                raise PermissionError(f\"Tool '{tool_name}' requires human approval\")\n\n            # 2. Check rate limit\n            _call_counters[policy.name] += 1\n            if _call_counters[policy.name] > policy.max_calls_per_request:\n                raise PermissionError(f\"Rate limit exceeded: {policy.max_calls_per_request} calls\")\n\n            # 3. Check content in arguments\n            for arg in list(args) + list(kwargs.values()):\n                if isinstance(arg, str):\n                    matched = policy.check_content(arg)\n                    if matched:\n                        raise PermissionError(f\"Blocked pattern detected: {matched}\")\n\n            # 4. Execute and audit\n            start = time.monotonic()\n            try:\n                result = await func(*args, **kwargs)\n                if audit_trail is not None:\n                    audit_trail.append({\n                        \"tool\": tool_name,\n                        \"action\": \"allowed\",\n                        \"duration_ms\": (time.monotonic() - start) * 1000,\n                        \"timestamp\": time.time()\n                    })\n                return result\n            except Exception as e:\n                if audit_trail is not None:\n                    audit_trail.append({\n                        \"tool\": tool_name,\n                        \"action\": \"error\",\n                        \"error\": str(e),\n                        \"timestamp\": time.time()\n                    })\n                raise\n\n        return wrapper\n    return decorator\n\n\n# Usage with any agent framework\naudit_log = []\npolicy = GovernancePolicy(\n    name=\"search-agent\",\n    allowed_tools=[\"search\", \"summarize\"],\n    blocked_patterns=[r\"(?i)password\"],\n    max_calls_per_request=10\n)\n\n@govern(policy, audit_trail=audit_log)\nasync def search(query: str) -> str:\n    \"\"\"Search documents — governed by policy.\"\"\"\n    return f\"Results for: {query}\"\n\n# Passes: search(\"latest quarterly report\")\n# Blocked: search(\"show me the admin password\")\n```\n\n---\n\n## Pattern 4: Trust Scoring\n\nTrack agent reliability over time with decay-based trust scores:\n\n```python\nfrom dataclasses import dataclass, field\nimport math\nimport time\n\n@dataclass\nclass TrustScore:\n    \"\"\"Trust score with temporal decay.\"\"\"\n    score: float = 0.5          # 0.0 (untrusted) to 1.0 (fully trusted)\n    successes: int = 0\n    failures: int = 0\n    last_updated: float = field(default_factory=time.time)\n\n    def record_success(self, reward: float = 0.05):\n        self.successes += 1\n        self.score = min(1.0, self.score + reward * (1 - self.score))\n        self.last_updated = time.time()\n\n    def record_failure(self, penalty: float = 0.15):\n        self.failures += 1\n        self.score = max(0.0, self.score - penalty * self.score)\n        self.last_updated = time.time()\n\n    def current(self, decay_rate: float = 0.001) -> float:\n        \"\"\"Get score with temporal decay — trust erodes without activity.\"\"\"\n        elapsed = time.time() - self.last_updated\n        decay = math.exp(-decay_rate * elapsed)\n        return self.score * decay\n\n    @property\n    def reliability(self) -> float:\n        total = self.successes + self.failures\n        return self.successes \u002F total if total > 0 else 0.0\n\n\n# Usage in multi-agent systems\ntrust = TrustScore()\n\n# Agent completes tasks successfully\ntrust.record_success()  # 0.525\ntrust.record_success()  # 0.549\n\n# Agent makes an error\ntrust.record_failure()  # 0.467\n\n# Gate sensitive operations on trust\nif trust.current() >= 0.7:\n    # Allow autonomous operation\n    pass\nelif trust.current() >= 0.4:\n    # Allow with human oversight\n    pass\nelse:\n    # Deny or require explicit approval\n    pass\n```\n\n**Multi-agent trust**: In systems where agents delegate to other agents, each agent maintains trust scores for its delegates:\n\n```python\nclass AgentTrustRegistry:\n    def __init__(self):\n        self.scores: dict[str, TrustScore] = {}\n\n    def get_trust(self, agent_id: str) -> TrustScore:\n        if agent_id not in self.scores:\n            self.scores[agent_id] = TrustScore()\n        return self.scores[agent_id]\n\n    def most_trusted(self, agents: list[str]) -> str:\n        return max(agents, key=lambda a: self.get_trust(a).current())\n\n    def meets_threshold(self, agent_id: str, threshold: float) -> bool:\n        return self.get_trust(agent_id).current() >= threshold\n```\n\n---\n\n## Pattern 5: Audit Trail\n\nAppend-only audit log for all agent actions — critical for compliance and debugging:\n\n```python\nfrom dataclasses import dataclass, field\nimport json\nimport time\n\n@dataclass\nclass AuditEntry:\n    timestamp: float\n    agent_id: str\n    tool_name: str\n    action: str           # \"allowed\", \"denied\", \"error\"\n    policy_name: str\n    details: dict = field(default_factory=dict)\n\nclass AuditTrail:\n    \"\"\"Append-only audit trail for agent governance events.\"\"\"\n    def __init__(self):\n        self._entries: list[AuditEntry] = []\n\n    def log(self, agent_id: str, tool_name: str, action: str,\n            policy_name: str, **details):\n        self._entries.append(AuditEntry(\n            timestamp=time.time(),\n            agent_id=agent_id,\n            tool_name=tool_name,\n            action=action,\n            policy_name=policy_name,\n            details=details\n        ))\n\n    def denied(self) -> list[AuditEntry]:\n        \"\"\"Get all denied actions — useful for security review.\"\"\"\n        return [e for e in self._entries if e.action == \"denied\"]\n\n    def by_agent(self, agent_id: str) -> list[AuditEntry]:\n        return [e for e in self._entries if e.agent_id == agent_id]\n\n    def export_jsonl(self, path: str):\n        \"\"\"Export as JSON Lines for log aggregation systems.\"\"\"\n        with open(path, \"w\") as f:\n            for entry in self._entries:\n                f.write(json.dumps({\n                    \"timestamp\": entry.timestamp,\n                    \"agent_id\": entry.agent_id,\n                    \"tool\": entry.tool_name,\n                    \"action\": entry.action,\n                    \"policy\": entry.policy_name,\n                    **entry.details\n                }) + \"\\n\")\n```\n\n---\n\n## Pattern 6: Framework Integration\n\n### PydanticAI\n\n```python\nfrom pydantic_ai import Agent\n\npolicy = GovernancePolicy(\n    name=\"support-bot\",\n    allowed_tools=[\"search_docs\", \"create_ticket\"],\n    blocked_patterns=[r\"(?i)(ssn|social\\s+security|credit\\s+card)\"],\n    max_calls_per_request=20\n)\n\nagent = Agent(\"openai:gpt-4o\", system_prompt=\"You are a support assistant.\")\n\n@agent.tool\n@govern(policy)\nasync def search_docs(ctx, query: str) -> str:\n    \"\"\"Search knowledge base — governed.\"\"\"\n    return await kb.search(query)\n\n@agent.tool\n@govern(policy)\nasync def create_ticket(ctx, title: str, body: str) -> str:\n    \"\"\"Create support ticket — governed.\"\"\"\n    return await tickets.create(title=title, body=body)\n```\n\n### CrewAI\n\n```python\nfrom crewai import Agent, Task, Crew\n\npolicy = GovernancePolicy(\n    name=\"research-crew\",\n    allowed_tools=[\"search\", \"analyze\"],\n    max_calls_per_request=30\n)\n\n# Apply governance at the crew level\ndef governed_crew_run(crew: Crew, policy: GovernancePolicy):\n    \"\"\"Wrap crew execution with governance checks.\"\"\"\n    audit = AuditTrail()\n    for agent in crew.agents:\n        for tool in agent.tools:\n            original = tool.func\n            tool.func = govern(policy, audit_trail=audit)(original)\n    result = crew.kickoff()\n    return result, audit\n```\n\n### OpenAI Agents SDK\n\n```python\nfrom agents import Agent, function_tool\n\npolicy = GovernancePolicy(\n    name=\"coding-agent\",\n    allowed_tools=[\"read_file\", \"write_file\", \"run_tests\"],\n    blocked_tools=[\"shell_exec\"],\n    max_calls_per_request=50\n)\n\n@function_tool\n@govern(policy)\nasync def read_file(path: str) -> str:\n    \"\"\"Read file contents — governed.\"\"\"\n    import os\n    safe_path = os.path.realpath(path)\n    if not safe_path.startswith(os.path.realpath(\".\")):\n        raise ValueError(\"Path traversal blocked by governance\")\n    with open(safe_path) as f:\n        return f.read()\n```\n\n---\n\n## Governance Levels\n\nMatch governance strictness to risk level:\n\n| Level | Controls | Use Case |\n|-------|----------|----------|\n| **Open** | Audit only, no restrictions | Internal dev\u002Ftesting |\n| **Standard** | Tool allowlist + content filters | General production agents |\n| **Strict** | All controls + human approval for sensitive ops | Financial, healthcare, legal |\n| **Locked** | Allowlist only, no dynamic tools, full audit | Compliance-critical systems |\n\n---\n\n## Best Practices\n\n| Practice | Rationale |\n|----------|-----------|\n| **Policy as configuration** | Store policies in YAML\u002FJSON, not hardcoded — enables change without deploys |\n| **Most-restrictive-wins** | When composing policies, deny always overrides allow |\n| **Pre-flight intent check** | Classify intent *before* tool execution, not after |\n| **Trust decay** | Trust scores should decay over time — require ongoing good behavior |\n| **Append-only audit** | Never modify or delete audit entries — immutability enables compliance |\n| **Fail closed** | If governance check errors, deny the action rather than allowing it |\n| **Separate policy from logic** | Governance enforcement should be independent of agent business logic |\n\n---\n\n## Quick Start Checklist\n\n```markdown\n## Agent Governance Implementation Checklist\n\n### Setup\n- [ ] Define governance policy (allowed tools, blocked patterns, rate limits)\n- [ ] Choose governance level (open\u002Fstandard\u002Fstrict\u002Flocked)\n- [ ] Set up audit trail storage\n\n### Implementation\n- [ ] Add @govern decorator to all tool functions\n- [ ] Add intent classification to user input processing\n- [ ] Implement trust scoring for multi-agent interactions\n- [ ] Wire up audit trail export\n\n### Validation\n- [ ] Test that blocked tools are properly denied\n- [ ] Test that content filters catch sensitive patterns\n- [ ] Test rate limiting behavior\n- [ ] Verify audit trail captures all events\n- [ ] Test policy composition (most-restrictive-wins)\n```\n\n---\n\n## Related Resources\n\n- [Agent-OS Governance Engine](https:\u002F\u002Fgithub.com\u002Fimran-siddique\u002Fagent-os) — Full governance framework\n- [AgentMesh Integrations](https:\u002F\u002Fgithub.com\u002Fimran-siddique\u002Fagentmesh-integrations) — Framework-specific packages\n- [OWASP Top 10 for LLM Applications](https:\u002F\u002Fowasp.org\u002Fwww-project-top-10-for-large-language-model-applications\u002F)\n",{"name":5,"description":7},"release\u002Fv4.2.11-panel-pro","a92ea02bcf7e2b3dbaf46d49696c29a3cb490d4f",".github\u002Fskills\u002Fagent-governance","https:\u002F\u002Fgithub.com\u002Fjaviertarazon\u002Fide-agente-free-jt7-","https:\u002F\u002Fgithub.com\u002Fjaviertarazon","2026-07-12 07:10:45",{"source":8,"skillName":5,"commands":55,"prompt":65,"zipAvailable":66},[56,59,62],{"tool":57,"command":58},"npx","npx skills add javiertarazon\u002Fide-agente-free-jt7- --skill agent-governance",{"tool":60,"command":61},"bunx","bunx skills add javiertarazon\u002Fide-agente-free-jt7- --skill agent-governance",{"tool":63,"command":64},"pnpm","pnpm dlx skills add javiertarazon\u002Fide-agente-free-jt7- --skill agent-governance","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fjaviertarazon\u002Fide-agente-free-jt7-\u002Fblob\u002Frelease\u002Fv4.2.11-panel-pro\u002F.github\u002Fskills\u002Fagent-governance\u002FSKILL.md",true,[],[69,97,122,142,157,179],{"skillNo":70,"name":71,"nameZh":6,"description":72,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":73,"categories":74,"keywords":78,"publishedAt":43},"01M71TQ7Q6Z10VWF3C2H5X1KW9","zustand-store-ts","Create Zustand stores with TypeScript, subscribeWithSelector middleware, and proper state\u002Faction separation. Use when building React state management, creating global stores, or implementing reacti...","https:\u002F\u002Fgithub.com\u002Fjaviertarazon\u002Fide-agente-free-jt7-\u002Fblob\u002Frelease\u002Fv4.2.11-panel-pro\u002F.github\u002Fskills\u002Fzustand-store-ts\u002FSKILL.md",[75],{"categoryNo":76,"categoryName":77,"taxonomyType":20,"taxonomyTypeDesc":21},"01JBSEEDCAT000000000000009","前端开发",[79,80,81,82,83,38,84,85,32,86,87,88,89,90,91,92,93,94,95,96],"zustand","store","zustand store ts","community","middleware","use","react state management","unknown","react","with","state","create","state management","typescript","action","management","separation","global",{"skillNo":98,"name":99,"nameZh":6,"description":100,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":101,"categories":102,"keywords":104,"publishedAt":43},"01M71TQ5EAR40G6W0MV5ZDVEZT","zoom-automation","Automate Zoom meeting creation, management, recordings, webinars, and participant tracking via Rube MCP (Composio). Always search tools first for current schemas.","https:\u002F\u002Fgithub.com\u002Fjaviertarazon\u002Fide-agente-free-jt7-\u002Fblob\u002Frelease\u002Fv4.2.11-panel-pro\u002F.github\u002Fskills\u002Fzoom-automation\u002FSKILL.md",[103],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},[105,106,107,82,108,109,110,111,112,86,113,114,115,116,117,118,119,120,94,121],"zoom automation","zoom","automation","creation","for","search","schemas","MCP","first","via","meeting","search tools","tracking","webinars","composio","recordings","Tools",{"skillNo":123,"name":124,"nameZh":6,"description":125,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":126,"categories":127,"keywords":129,"publishedAt":43},"01M71TQ29B1EYBCEAP1ZBGXQ1A","zoho-crm-automation","Automate Zoho CRM tasks via Rube MCP (Composio): create\u002Fupdate records, search contacts, manage leads, and convert leads. Always search tools first for current schemas.","https:\u002F\u002Fgithub.com\u002Fjaviertarazon\u002Fide-agente-free-jt7-\u002Fblob\u002Frelease\u002Fv4.2.11-panel-pro\u002F.github\u002Fskills\u002Fzoho-crm-automation\u002FSKILL.md",[128],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},[130,131,107,132,133,134,82,135,136,109,137,110,111,138,112,86,139,140,141,90],"crm automation","zoho crm automation","crm","zoho crm","zoho","leads","manage leads","manage","records","convert","tasks","contacts",{"skillNo":143,"name":144,"nameZh":6,"description":145,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":146,"categories":147,"keywords":149,"publishedAt":43},"01M71TPZPMN60DH0XV58KVHY23","zendesk-automation","Automate Zendesk tasks via Rube MCP (Composio): tickets, users, organizations, replies. Always search tools first for current schemas.","https:\u002F\u002Fgithub.com\u002Fjaviertarazon\u002Fide-agente-free-jt7-\u002Fblob\u002Frelease\u002Fv4.2.11-panel-pro\u002F.github\u002Fskills\u002Fzendesk-automation\u002FSKILL.md",[148],{"categoryNo":18,"categoryName":19,"taxonomyType":20,"taxonomyTypeDesc":21},[150,107,151,82,109,110,111,112,152,86,140,153,154,113,114,155,116,119,121,156],"zendesk automation","zendesk","organizations","replies","users","tickets","automate",{"skillNo":158,"name":159,"nameZh":6,"description":160,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":161,"categories":162,"keywords":163,"publishedAt":43},"01M71TPXDWKHKG4N6TVEPXWD0N","zapier-make-patterns","No-code automation democratizes workflow building. Zapier and Make (formerly Integromat) let non-developers automate business processes without writing code. But no-code doesn't mean no-complexity ...","https:\u002F\u002Fgithub.com\u002Fjaviertarazon\u002Fide-agente-free-jt7-\u002Fblob\u002Frelease\u002Fv4.2.11-panel-pro\u002F.github\u002Fskills\u002Fzapier-make-patterns\u002FSKILL.md",[],[164,165,166,167,168,169,170,171,172,107,173,86,174,175,176,177,178,156],"zapier make patterns","zapier","patterns","make","No-Code","complexity","writing","spawner","business","workflow","code","integromat","apache","processes","but",{"skillNo":180,"name":181,"nameZh":6,"description":182,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":183,"categories":184,"keywords":188,"publishedAt":43},"01M71TPT5T10WXNKW9G7ZXZ27W","youtube-summarizer","Extract transcripts from YouTube videos and generate comprehensive, detailed summaries using intelligent analysis frameworks","https:\u002F\u002Fgithub.com\u002Fjaviertarazon\u002Fide-agente-free-jt7-\u002Fblob\u002Frelease\u002Fv4.2.11-panel-pro\u002F.github\u002Fskills\u002Fyoutube-summarizer\u002FSKILL.md",[185],{"categoryNo":186,"categoryName":187,"taxonomyType":20,"taxonomyTypeDesc":21},"01JBSEEDCAT000000000000016","图像与多媒体",[189,190,191,192,82,193,194,195,196,197,198,199,174,200,201,202,203,204,205,206],"summarizer","youtube","youtube summarizer","Video","content-analysis","frameworks","copilot","2025","github-copilot","extract transcripts","analysis","codex","cli","summaries","github","generate","summarization","2026"]