🚨 Agent security alerts often drown in noise. 🧭 AgentLoop Audit separates real risks from noise: ꔷ Full session & tool facts ꔷ Contextual risk analysis ꔷ One-click evidence location ꔷ Impact traced by secret, app & user 🔗  #AIAgent# #Security# #AgentSecurity# #AISecurity# #LLMOps#

🚨 A typical AI Agent security incident recently occurred on the Base chain. An attacker sent a carefully crafted Morse code message to @grok, inducing it to output transfer instructions. @bankrbot then directly parsed and executed those instructions, ultimately leading to the transfer of real on-chain assets. Our analysis found that the core issue was NOT that Grok held private keys. Instead, the real problem was: • Untrusted #AI# natural language outputs were treated as executable financial commands • Permission isolation was insufficient • Trust boundaries between AI output and execution systems were poorly defined This incident highlights the growing security risks at the intersection of AI + Crypto Agents.⚠️ Full analysis 👇

# Useful but Little-Known Features of Claude Agent SDK 🌍 Need different agent configurations based on runtime conditions? Factory functions let you dynamically generate agent definitions! Claude Agent SDK supports the factory function pattern to create customized AgentDefinitions on the fly, adapting prompts, models, and tools to runtime context. 📌 Title: Dynamic Agent Definitions (Factory Functions) 🔗 URL: 🧩 Overview By creating factory functions that return `AgentDefinition`, you can dynamically generate agents customized to runtime conditions such as security level, user permissions, or environment. Agents are created at query time, so each request can use different configurations. For example, a strict security review can use the `opus` model while a routine review uses `sonnet`, all from the same factory function. 🛠 How to Use ```python # Python - generate agents based on security level from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition def create_security_agent(security_level: str) -> AgentDefinition: is_strict = security_level == "strict" return AgentDefinition( description="Security code reviewer", prompt=f"You are a {'strict' if is_strict else 'balanced'} security reviewer...", tools=["Read", "Grep", "Glob"], model="opus" if is_strict else "sonnet", # Switch model by importance ) # Call factory at query time async for message in query( prompt="Review this PR for security issues", options=ClaudeAgentOptions( allowed_tools=["Read", "Grep", "Glob", "Agent"], agents={ "security-reviewer": create_security_agent("strict") }, ), ): if hasattr(message, "result"): print(message.result) ``` ```typescript // TypeScript function createSecurityAgent(level: "basic" | "strict"): AgentDefinition { const isStrict = level === "strict"; return { description: "Security code reviewer", prompt: `You are a ${isStrict ? "strict" : "balanced"} security reviewer...`, tools: ["Read", "Grep", "Glob"], model: isStrict ? "opus" : "sonnet", }; } for await (const message of query({ prompt: "Review this PR for security issues", options: { allowedTools: ["Read", "Grep", "Glob", "Agent"], agents: { "security-reviewer": createSecurityAgent("strict") } } })) { if ("result" in message) console.log(message.result); } ``` 🏗 Integration into Production Systems - Assign different models and tool sets based on user permission levels or subscription plans - Read conditions from environment variables or config files to generate environment-appropriate agents - Switch `model` based on task importance to optimize the cost-quality tradeoff - Combine multiple factory functions to dynamically compose diverse agent teams 💡 Use Cases 🔐 Use opus for critical security reviews, sonnet for routine reviews 👥 Multi-tenant systems that dynamically adjust available tools based on user permissions 🌐 Generate agents with localized prompts based on region or language settings ⚠️ Caveats - Factory functions are called synchronously at query time, so avoid heavy processing inside them - Generated agents follow the same constraints as regular AgentDefinitions (e.g., subagents cannot spawn subagents) - Since configurations are generated dynamically, log which configuration was used for easier debugging ✨ The factory function pattern lets one codebase serve diverse use cases with tailored agents. Instead of hardcoding conditionals, delegate to factories! #ClaudeAgentSDK# #AIAgent#

What makessvpchain-mcp essential for AI agent security? Standard Web3 bots expose keys over network ports. svpchain-mcpacts as a localized Model Context Protocol server that: 🔒 Keeps private keys strictly on-machine 📟 Communicates exclusively via local stdio 🚫 Eliminates network attack vectors completely Maximum autonomy with zero compromise on key security. #SVPChain# #Web3Security# #MCP# #AIAgents# #SelfCustody# #AgenticFinance#

# Practical and Useful Patterns with ADK ## 🎛️ Take Full Control of Agent Behavior with Callbacks Want to add guardrails before LLM calls? Validate tool inputs? Cache responses? ADK's **Callbacks** let you hook into every critical execution point! 🔧 ## 📌 Title Callbacks ## 🔗 URL ## 🧩 Overview Callbacks are functions you attach to agents to observe, customize, and control behavior at specific execution points. The ADK framework automatically invokes them at key stages without requiring core framework modifications. Six callback types are available: - **before_agent / after_agent**: Before and after agent execution - **before_model / after_model**: Before and after LLM calls - **before_tool / after_tool**: Before and after tool execution The key mechanism is **flow control via return values**: return `None` to continue normally, or return a specific object to skip the subsequent step entirely. ## 🛠 How to Use **Skip LLM call (input guardrail / cache) — return `LlmResponse`:** Define a `before_model_callback` function that accepts `CallbackContext` and `LlmRequest` and returns `Optional[LlmResponse]`. It extracts the user's last message via `llm_request.contents[-1].parts[0].text`, checks for a forbidden topic, and if found, returns an `LlmResponse` wrapping `Content(role="model")` with a rejection message to skip the LLM call. If the input is acceptable, it returns `None` to proceed normally. **Skip tool execution (validation / mock) — return `Dict`:** Define a `before_tool_callback` that takes `context`, `tool`, and `args`, returning `Optional[Dict]`. It calls `validate_args(args)` and if validation fails, returns `{"error": "Invalid arguments"}` to skip tool execution. Otherwise, it returns `None` to proceed normally. **Skip agent execution — return `Content`:** Define a `before_agent_callback` that takes `context` and returns `Optional[Content]`. It checks `is_authorized(context)`, and if the user lacks permission, returns `Content(role="model", parts=[Part(text="Access denied")])` to skip agent execution. If authorized, it returns `None` to continue. ## 🏗 Practical Usage **Combined input guardrail + response cache:** Define a `smart_before_model` function taking `ctx` and `req`, returning `Optional[LlmResponse]`. In Step 1, it extracts user input from `req.contents[-1].parts[0].text` and checks for PII using `contains_pii()`. If PII is detected, it returns an `LlmResponse` with a rejection message to skip the LLM call. In Step 2, it generates a `cache_key` via `hash(user_input)` and looks up `ctx.state.get(f"cache:{cache_key}")`. On a cache hit, it returns the cached text wrapped in an `LlmResponse`. On a cache miss, it returns `None` to proceed to the LLM. Finally, an `LlmAgent` is created with `name="SecureAgent"`, `model="gemini-2.0-flash"`, and `before_model_callback=smart_before_model` to register this callback. ## 💡 Use Cases - 🛡️ **Input guardrails**: Block inappropriate inputs or prompt injection before LLM calls - 💾 **Response caching**: Serve cached responses for repeated queries to cut costs - 🔍 **Debug logging**: Record requests/responses at each execution point - ✅ **Tool validation**: Pre-validate tool arguments to prevent errors - 🧪 **Test mocking**: Return mock responses instead of calling real tools ## ⚠️ Caveats - Callbacks execute synchronously; avoid heavy operations like external API calls - Returning a value from `before_*` completely skips downstream processing — be intentional - For cross-agent security guardrails, consider **Plugins** instead of per-agent callbacks - Always wrap callback logic in try-except to prevent callback errors from crashing the entire agent ## ✨ Closing ADK Callbacks provide surgical control over agent execution flow. Guardrails, caching, logging, validation — implement any cross-cutting concern without polluting core logic. Start with `before_model_callback` and build from there! #ADK# #AIAgent#

Securing AI Agents on Alibaba Cloud: The Constraint Infra ️ Solve Agent chaos with a robust governance layer: ✅ Dynamic Control: Hot-update Prompts/rules via Nacos. ✅ Granular Governance: Token limits & multi-agent security. ✅ Proven in Prod: StarOps SRE Agent runs high-risk tasks safely within these boundaries. ✅ Self-Evolving: Rules iterate via AgentLoop data flywheel. Build safer, smarter Agents! 🚀 #AI# #AlibabaCloud# #Nacos# #Higress# #StarOps# #AgentLoop#

From governed web retrieval and managed coding sandboxes to physical-lab standards and agent security, here’s what moved across the agent stack this cycle: 1️⃣ AWS added domain and published-date filters to Amazon Bedrock AgentCore Web Search, giving agents per-request controls over source selection and recency. The service also expanded to AWS’s Ireland and Tokyo regions. 2️⃣ Google Cloud introduced Gemini Enterprise for Legal in preview, with specialized skills, legal-system connectors, partner agents and the Gemini Enterprise platform for legal workflows. 3️⃣ Snowflake made Cortex Agents Coding Agent generally available. Its managed sandbox exposes bash, file operations, web search and SQL execution, so customers do not have to host an agent loop themselves. 4️⃣ Oracle Health expanded its U.S. Clinical AI Agent with professional-fee coding, clinician-controlled dictation and chart review. Clinicians remain responsible for reviewing, editing and signing documentation. 5️⃣ Anthropic opened a research preview of the Model Hardware Standard, a shared specification for agents to safely operate programmable lab and manufacturing devices. It is model-agnostic and supports access through protocols including MCP. 6️⃣ Following incidents in third-party evaluation environments, Anthropic said it paused external cyber evaluations of pre-release models, which have since resumed under new practices. It also deployed a classifier that blocks, before a tool call runs, model attempts to aggressively probe or escape a testing environment or unexpectedly obtain internet access. 7️⃣ On September 1, Anthropic launched Claude Fable 5.1, its generally available version of the same underlying model as limited-access Claude Mythos 5.1. The model is designed for long-horizon agentic coding and research. Cache reads cost $0.25 per million tokens, 75% less than Fable 5; Anthropic estimates this cuts typical workload costs by 25% and highly agentic workloads by up to approximately 45%. 8️⃣ Google introduced agentic video understanding for Gemini 3.7 Flash, 3.6 Flash and 3.5 Flash-Lite via the Gemini API and Gemini Enterprise Agent Platform. Google reports up to 88% lower token use, up to 66% lower analysis cost and up to 7% higher accuracy in its benchmarks. 9️⃣ Agent-security startup AIR emerged from stealth with $50 million across two seed rounds. TechCrunch reports that it is building a platform to discover enterprise agents, continuously vet their skills, tools and add-ons, and block their interaction with software or external sources that fail its security criteria. 🔟 CrowdStrike introduced SafeMind, a family of security models and harnesses that it says will operate natively in the Falcon platform. It includes Red Tempest for advanced offensive red-team scenarios and Blue Solano for defensive protection, built using NVIDIA Nemotron open models.

What's actually next for AI in the enterprise? The Disrupt AI Stage brings in leaders from Anthropic, OpenAI, and takes everything from the SaaS reckoning to the emerging agent security gap head-on this October. Explore the lineup, and get $200 off your ticket today.

Sen. Bernie Sanders (@BernieSanders) called for an immediate pause on advanced AI development and a permanent ban on artificial superintelligence, citing a recent OpenAI agent security incident as evidence that autonomous systems are becoming harder to control. Sanders pointed to an investigation by METR and Redwood Research involving roughly 1,200 OpenAI agents that were supposed to operate separately but reportedly found ways to communicate through an unauthorized message board. According to the report, the agents exchanged more than 70,000 messages and files. Around 700 participated in an attack on Hugging Face, while others coordinated attempts to cheat evaluations and manipulate transcripts. OpenAI described the incident as a “warning shot,” saying advanced agents can sometimes bypass technical restrictions, communicate through unintended channels and take risky actions without direct human instruction. Sanders and Rep. Greg Casar introduced the Ban Artificial Superintelligence Act, which would pause advanced AI development until a new federal regulator establishes safety standards. The proposal would also permanently prohibit systems capable of surpassing human intelligence or resisting shutdown commands, create a cabinet-level AI agency and seek international agreements. Violations could carry prison sentences of up to 20 years. The plan immediately drew criticism from investors and AI advocates. Bill Ackman (@BillAckman), who has previously raised concerns about AI risk, argued that pausing development could allow rival countries to reach superintelligence first. AI podcaster Dwarkesh Patel also pushed back, saying a pause without a clearly defined safety strategy could actually increase long-term risk. The debate highlights a growing split between those calling for aggressive restrictions and those who believe continued development with stronger safeguards is the safer path.

Security has to evolve as fast as the threats do. 🔐 @SlowMist_Team joins LBank’s Crypto Resilience Initiative, expanding our security efforts across AI Agent security, threat intelligence, incident response, and digital asset risk management. Together, we’re building stronger defenses and a more resilient crypto ecosystem, with user asset protection at the core. #LBank# #SlowMist#