Which agents will be successful and which one be. The simple litmus test is A2A.
Enterprises already are or will complain about AI agent sprawl. Too many agents not working together.
If you are making an agent and it can’t cowork with other agents you probably won’t survive. #AI #MCP #A2A
MCP, Agent Skills and A2A are not the same thing.
Most people building AI agents mix them up.
Here's the simple version:
• MCP = the hands
It connects your agent to tools and data: GitHub, Slack, your database, your files.
• Agent Skills = the know-how
Folders of instructions and scripts that teach the agent how to do a specific job. It only loads them when the task needs them, so its memory stays clean.
• A2A = the teamwork
Lets one agent hand a task to a different agent and get the result back.
Think of hiring someone:
- MCP gives them the laptop and logins.
- Skills give them the training manual.
- A2A lets them pass work to a coworker.
They don't compete. The best agents use all three together.
Now all three are open standards, shared under the Linux Foundation, so they work across Google, Anthropic, OpenAI and more.
Bookmark it and send it to the friend who keeps saying "just use MCP for everything."
Aid isn't just money. Providing political legitimacy, turning a blind eye to human rights abuses, or withholding warranted sanctions are all powerful forms of support @AbdulElSayed@TheWatchman_2@worqas
A lot of chatter about US Senator-elect @AbdulElSayed's statement on cutting aid to Pakistan. 🇵🇰
Habibi, I have one question: WHAT AID?
Let's break down the ground realities to avoid any misconceptions moving forward. 🧵
@alexey_anshakov Agreed .
The gateway can't lie (mostly) about what it saw. It can't tell you what it never saw.
When everything else is bypassed, the network is the last line.
Great list. It covers how to build AI securely. Here's the other half: how to keep it secure once it's running. Recent agentic intrusions didn't fail at the prompt. They failed at runtime.
Stage 13: Runtime Detection & AI Telemetry
- Learn: OpenTelemetry for agents, tool-call and MCP logging, AI gateway logs, behavioural baselining of agents.
- Practice: Instrument an agent, stream its telemetry to a SIEM, and write detections for unusual tool use and new destinations.
- Why: Agent logs are self-reported. You need independent evidence of what the agent actually did, not just what it says it did.
Stage 14: AI Supply Chain
- Learn: Unsafe model formats (pickle, HDF5), model signing, AI-BOMs, slopsquatting (hallucinated package names), malicious MCP servers.
- Practice: Build a CI gate that scans model artifacts for unsafe formats and verifies signatures before deployment.
- Why: Models and MCP servers are the new third-party code. A poisoned model file is RCE with a friendly name.
Stage 15: AI Infrastructure & Agent Containment
- Learn: Exposed model servers and AI workflow tools, LLMjacking (stolen API keys), GPU hijacking, egress control for agent sandboxes.
- Practice: Lock down a code-executing agent so it can only reach approved destinations, then try to break out.
- Why: The real attacks start with an exposed AI tool or a sandbox escape, followed by lateral movement. No guardrail on the prompt stops that.
Stage 16: Shadow AI Discovery & Inventory
- Learn: Finding AI from network, endpoint and cloud data; non-human identity sprawl; mapping who talks to which model.
- Practice: Build a live inventory of every model, agent and MCP server in a lab network, and what each one talks to.
- Why: You can't govern, red team or audit AI you don't know exists.
Stage 17: AI Incident Response
- Learn: Machine-speed containment, credential revocation, agent session forensics, public incident teardowns.
- Practice: Run a tabletop: an agent goes rogue at 3am. Who kills it, how, and what evidence do you keep?
- Why: In recent incidents the signals fired. Nobody connected them in time. Detection without response is a log file.
One tweak to Stage 11: an audit log the agent writes about itself proves nothing. Verify it against an independent source.
Build-time security gets you to launch. Runtime security keeps you out of the incident report. #AIThreat
If you learn AI Security Engineering, you will never be unemployed again.
I’ll do this.
Stage 1: AI Attack Surfaces & Threat Modeling
- Learn: OWASP Top 10 for LLMs, STRIDE for AI, the "Confused Deputy" problem in agentic workflows & data flow mapping.
- Practice: Draw a complete threat model for an AI agent that reads emails and writes to a CRM, identifying every indirect injection and data exfiltration vector.
- Why: You cannot secure an agentic workflow if you don't understand how an attacker can hijack the agent's legitimate privileges.
Stage 2: Advanced Prompt Injection & Jailbreaking
- Learn: Direct vs. Indirect injection, Crescendo attacks (multi-turn grooming), payload splitting and encoding evasion (Base64, ROT13).
- Practice: Build an automated harness that successfully bypasses a commercial LLM's system prompt using a multi-turn Crescendo strategy.
- Why: Basic "ignore previous instructions" filters are trivial to bypass. Modern attacks groom the model's context over multiple turns.
Stage 3: Agentic Security & MCP Tool Poisoning
- Learn: Model Context Protocol (MCP) security, JSON-RPC sanitization, shadow tool execution and least-privilege scoping for agents.
- Practice: Write an MCP server that strictly validates incoming tool parameters via Pydantic and blocks "confused deputy" attacks where a user prompt tries to access admin tools.
- Why: Agents are only as secure as the tools they call. Tool poisoning is the SQL Injection of the Agentic Era.
Stage 4: RAG Security & Data Poisoning
- Learn: Vector DB access control, citation spoofing, shadow context injection and row-level security for semantic search.
- Practice: Inject a "poisoned" document into a RAG pipeline that forces the LLM to output a specific malicious URL when queried about company policy.
- Why: If an attacker can slip a poisoned document into your knowledge base, they own every answer the AI generates.
Stage 5: PII, Privacy & Cryptographic Guardrails
- Learn: Deterministic masking, UUID swapping, differential privacy and pre-flight/post-flight unmasking proxies.
- Practice: Build a middleware proxy that intercepts user prompts, swaps SSNs and credit cards for UUIDs before the LLM sees them and restores them post-generation.
- Why: Compliance teams will kill any AI product that sends raw customer PII to a third-party frontier API.
Stage 6: Identity, Auth & Delegated Access for Agents
- Learn: OAuth2 for machine identities, scoped JWTs, human-in-the-loop (HITL) approval gates and agent-to-agent (A2A) trust boundaries.
- Practice: Build an auth broker where an AI agent acts on a user's behalf using a heavily scoped, time-limited OAuth token, rather than holding the user's raw password.
- Why: Agents need hands but they should never hold the master keys to the enterprise.
Stage 7: Output Validation & Grammar-Constrained Guardrails
- Learn: CFG (Context-Free Grammar) decoding, NeMo Guardrails, output sanitization and regex-enforced JSON schemas.
- Practice: Implement a guardrail layer that physically prevents the LLM from generating markdown links or executable code blocks in its final output.
- Why: You cannot rely on the system prompt to "please don't output bad things." You must enforce it at the token-decoding level.
Stage 8: Automated Red Teaming & Fuzzing
- Learn: Microsoft PyRIT, Garak, LLM-based fuzzing, adversarial dataset generation and CI/CD security gates.
- Practice: Build a CI pipeline using PyRIT that automatically attacks your agent with 1,000 adversarial payloads on every PR, blocking merges if the jailbreak rate exceeds 1%.
- Why: Manual red teaming doesn't scale. You need automated, continuous adversarial fuzzing integrated directly into your deployment pipeline.
Stage 9: Model Extraction & IP Protection
- Learn: Membership inference attacks, model inversion, API rate-limiting by semantic similarity and output watermarking.
- Practice: Build an API gateway that detects and blocks scraping bots trying to extract your fine-tuned model's weights via thousands of systematic, low-temperature queries.
- Why: Your fine-tuned model's weights are your IP. Competitors will try to distill your model through the public API.
Stage 10: Mechanistic Interpretability & Alignment Safety
- Learn: Activation patching, logit lens, circuit discovery, detecting reward hacking and tools like TransformerLens.
- Practice: Locate the specific attention heads in an open-source model responsible for "deception" or "sycophancy" and patch their activations to neutralize the behavior.
- Why: You cannot fix hidden biases or misalignment if you treat the neural network as a black box.
Stage 11: Compliance, Auditing & Governance
- Learn: EU AI Act requirements, NIST AI RMF, immutable audit trails, SOC2 for AI and bias testing frameworks.
- Practice: Build an immutable, append-only audit log that records the exact prompt, retrieved context, tool calls and final output for every single agent action.
- Why: When an AI agent makes a mistake that causes financial or legal damage, the enterprise must be able to prove exactly why it happened.
Stage 12: Public CVEs, Teardowns & Portfolios
- Learn: Responsible disclosure, writing security advisories, publishing threat models and bug bounty hunting for AI.
- Practice: Find a vulnerability in an open-source AI framework (like LangChain or an MCP server), responsibly disclose it and publish a teardown of the exploit chain.
- Why: AI Security is a brand new field. Publishing novel attack vectors and defenses makes you the undisputed authority in the space.
Bookmark and Repost!
If you learn AI Security Engineering, you will never be unemployed again.
I’ll do this.
Stage 1: AI Attack Surfaces & Threat Modeling
- Learn: OWASP Top 10 for LLMs, STRIDE for AI, the "Confused Deputy" problem in agentic workflows & data flow mapping.
- Practice: Draw a complete threat model for an AI agent that reads emails and writes to a CRM, identifying every indirect injection and data exfiltration vector.
- Why: You cannot secure an agentic workflow if you don't understand how an attacker can hijack the agent's legitimate privileges.
Stage 2: Advanced Prompt Injection & Jailbreaking
- Learn: Direct vs. Indirect injection, Crescendo attacks (multi-turn grooming), payload splitting and encoding evasion (Base64, ROT13).
- Practice: Build an automated harness that successfully bypasses a commercial LLM's system prompt using a multi-turn Crescendo strategy.
- Why: Basic "ignore previous instructions" filters are trivial to bypass. Modern attacks groom the model's context over multiple turns.
Stage 3: Agentic Security & MCP Tool Poisoning
- Learn: Model Context Protocol (MCP) security, JSON-RPC sanitization, shadow tool execution and least-privilege scoping for agents.
- Practice: Write an MCP server that strictly validates incoming tool parameters via Pydantic and blocks "confused deputy" attacks where a user prompt tries to access admin tools.
- Why: Agents are only as secure as the tools they call. Tool poisoning is the SQL Injection of the Agentic Era.
Stage 4: RAG Security & Data Poisoning
- Learn: Vector DB access control, citation spoofing, shadow context injection and row-level security for semantic search.
- Practice: Inject a "poisoned" document into a RAG pipeline that forces the LLM to output a specific malicious URL when queried about company policy.
- Why: If an attacker can slip a poisoned document into your knowledge base, they own every answer the AI generates.
Stage 5: PII, Privacy & Cryptographic Guardrails
- Learn: Deterministic masking, UUID swapping, differential privacy and pre-flight/post-flight unmasking proxies.
- Practice: Build a middleware proxy that intercepts user prompts, swaps SSNs and credit cards for UUIDs before the LLM sees them and restores them post-generation.
- Why: Compliance teams will kill any AI product that sends raw customer PII to a third-party frontier API.
Stage 6: Identity, Auth & Delegated Access for Agents
- Learn: OAuth2 for machine identities, scoped JWTs, human-in-the-loop (HITL) approval gates and agent-to-agent (A2A) trust boundaries.
- Practice: Build an auth broker where an AI agent acts on a user's behalf using a heavily scoped, time-limited OAuth token, rather than holding the user's raw password.
- Why: Agents need hands but they should never hold the master keys to the enterprise.
Stage 7: Output Validation & Grammar-Constrained Guardrails
- Learn: CFG (Context-Free Grammar) decoding, NeMo Guardrails, output sanitization and regex-enforced JSON schemas.
- Practice: Implement a guardrail layer that physically prevents the LLM from generating markdown links or executable code blocks in its final output.
- Why: You cannot rely on the system prompt to "please don't output bad things." You must enforce it at the token-decoding level.
Stage 8: Automated Red Teaming & Fuzzing
- Learn: Microsoft PyRIT, Garak, LLM-based fuzzing, adversarial dataset generation and CI/CD security gates.
- Practice: Build a CI pipeline using PyRIT that automatically attacks your agent with 1,000 adversarial payloads on every PR, blocking merges if the jailbreak rate exceeds 1%.
- Why: Manual red teaming doesn't scale. You need automated, continuous adversarial fuzzing integrated directly into your deployment pipeline.
Stage 9: Model Extraction & IP Protection
- Learn: Membership inference attacks, model inversion, API rate-limiting by semantic similarity and output watermarking.
- Practice: Build an API gateway that detects and blocks scraping bots trying to extract your fine-tuned model's weights via thousands of systematic, low-temperature queries.
- Why: Your fine-tuned model's weights are your IP. Competitors will try to distill your model through the public API.
Stage 10: Mechanistic Interpretability & Alignment Safety
- Learn: Activation patching, logit lens, circuit discovery, detecting reward hacking and tools like TransformerLens.
- Practice: Locate the specific attention heads in an open-source model responsible for "deception" or "sycophancy" and patch their activations to neutralize the behavior.
- Why: You cannot fix hidden biases or misalignment if you treat the neural network as a black box.
Stage 11: Compliance, Auditing & Governance
- Learn: EU AI Act requirements, NIST AI RMF, immutable audit trails, SOC2 for AI and bias testing frameworks.
- Practice: Build an immutable, append-only audit log that records the exact prompt, retrieved context, tool calls and final output for every single agent action.
- Why: When an AI agent makes a mistake that causes financial or legal damage, the enterprise must be able to prove exactly why it happened.
Stage 12: Public CVEs, Teardowns & Portfolios
- Learn: Responsible disclosure, writing security advisories, publishing threat models and bug bounty hunting for AI.
- Practice: Find a vulnerability in an open-source AI framework (like LangChain or an MCP server), responsibly disclose it and publish a teardown of the exploit chain.
- Why: AI Security is a brand new field. Publishing novel attack vectors and defenses makes you the undisputed authority in the space.
Bookmark and Repost!
1. Basically what DeepSeek did was kept asking for Chain of Thought (CoT) for different queries.
2. Preventing Model Distillation attacks means using Safety Chain-of-Thought —training models to analyze intent in a "hidden" reasoning space.
3. Basically, AI is getting a "private inner monologue" to decide if a prompt infringes on its IP.
4. We humans do this too! We Self-Regulate based on risk: "Will this information harm me?" 🧠
5. If AI withholds info, it must at least stay transparent about the fact it’s holding back. (constructive refusal)🛡️ #AISafety #CyberSecurity #anthropic
We’ve identified industrial-scale distillation attacks on our models by DeepSeek, Moonshot AI, and MiniMax.
These labs created over 24,000 fraudulent accounts and generated over 16 million exchanges with Claude, extracting its capabilities to train and improve their own models.
#CyberSecurity The perimeter didn't just move; it dissolved. 🫠 Identity is the next frontier for protection.
Whether it’s NDR, XDR, or NG SIEM, the goal is the same: hunting for compromised Non-Human Identities (NHIs). If you aren't securing the machine identity, you aren't securing the stack.
The big question for 2026: Will ITDR remain a standalone powerhouse, or just become another “feature” in the DR alphabet soup? 🍜🛡️
#ITDR #CyberSecurity #XDR #NHI
Anthropic published a blog post one hour ago.
Cybersecurity stocks have lost $10B since.
CrowdStrike -6.5%. Cloudflare -6%. Okta -5.7%.
One blog post. One hour. $10B gone.
Claude Code Security is adding a very smart left-shift tool—not burning the house down.
This is what happens when people who don’t live in tech try to price tech. They panic-sell on headlines, not reality.
The security stack isn’t dying. It’s getting smarter……
@ifsecure@0vercl0k If the goal is to reveal the secret, then this code is not revealing the secret. It is displaying the contents of arr not the contents of secret.
get_elements_safe(secret, index) would solve that.
Yes #Emotet is back. No there is no significant change yet. Most products which used to detect it before will continue to do so. Unless you were blocking it with a url block list ur good. Keep an eye open #Emotet will change something to avoid detection in the coming days.