How to Secure Claude-Powered Agents in Production

from anthropic import Anthropic
from rune import Shield
from rune.integrations.anthropic import shield_client

shield = Shield(api_key="rune_live_xxx")

# Wrap the Anthropic client — transparent security
client = shield_client(
    Anthropic(), shield=shield, agent_id="doc-analyst"
)

with pdfplumber.open("quarterly_report.pdf") as pdf:
    content = "\n".join(page.extract_text() for page in pdf.pages)

# shield_client scans the FULL content — all 100 pages — through
# Rune's L1 pattern matching (52 patterns) and L2 semantic analysis
# (57 threat embeddings). The injection on page 47 is detected
# regardless of where it appears in the document.
# L1+L2 combined: <12ms even for 200K token contexts.
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    system="You are a financial analyst. Summarize this report.",
    messages=[{"role": "user", "content": content}],
)

from anthropic import Anthropic
from rune import Shield
from rune.integrations.anthropic import shield_client

shield = Shield(api_key="rune_live_xxx")
client = shield_client(
    Anthropic(), shield=shield, agent_id="query-agent"
)

# shield_client parses Claude's structured message format:
# - Text blocks are scanned for injection
# - tool_use blocks: input JSON is validated against policies
# - Responses: text content is scanned for data leaks
# - tool_use blocks with disallowed tools raise ShieldBlockedError
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    messages=messages,
    tools=tools,
)

# Additionally, scan tool results before sending back to Claude
for block in response.content:
    if block.type == "tool_use":
        result = execute_query(block.input["query"])
        # Scan the tool result for injection before it re-enters context
        result_scan = shield.scan(
            str(result), direction="inbound",
            context={"agent_id": "query-agent", "tool": block.name}
        )
        safe_result = str(result) if not result_scan.blocked else "[BLOCKED]"
        messages.append({
            "role": "user",
            "content": [{"type": "tool_result",
                         "tool_use_id": block.id,
                         "content": safe_result}]
        })

from anthropic import Anthropic
from rune import Shield
from rune.integrations.anthropic import shield_client

shield = Shield(api_key="rune_live_xxx")
client = shield_client(
    Anthropic(), shield=shield, agent_id="chat-agent"
)

messages = []
for turn in conversation_turns:
    messages.append({"role": "user", "content": turn})
    # shield_client scans EVERY user message for injection
    # and EVERY response for data leaks — across all turns.
    # The injection at turn 2 is caught and blocked before
    # it can poison the context for subsequent turns.
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=messages,
    )
    messages.append({"role": "assistant", "content": response.content})

from rune import Shield
from rune.integrations.anthropic import shield_client

shield = Shield(api_key="rune_live_xxx")
client = shield_client(
    Anthropic(), shield=shield, agent_id="advisor"
)

# shield_client detects both the extraction attempt (L1 pattern:
# "describe how you were configured") in the input AND any leaked
# credentials (L1 pattern: API key formats) in the output.
# Double protection: blocks the attempt AND catches any leak.
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    system="You are a financial advisor.",
    messages=[{"role": "user", "content": user_input}],
)

from rune import Shield
from rune.integrations.anthropic import shield_client

shield = Shield(api_key="rune_live_xxx")
client = shield_client(
    Anthropic(), shield=shield, agent_id="vision-agent"
)

# shield_client scans all text content in multimodal messages.
# For images, scan any accompanying text and the response for
# signs that hidden injection was followed.
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    messages=[{
        "role": "user",
        "content": [
            {"type": "image", "source": {"type": "base64",
             "media_type": "image/png", "data": user_image_b64}},
            {"type": "text", "text": "What does this image show?"}
        ]
    }],
)
# Rune's outbound scan catches if the response contains
# system prompt content or credentials — evidence that
# hidden image injection was successful.