Agentium

Harden the autonomous world.

[AgentSec @agentsec_sh]

Introducing AgentSec — security auditing for AI agent skills with built-in web3 support.

OWASP AST10 covers generic skill risks. Our AST-10 Web3 Annex extends it with 12 onchain-specific rules: signing authority, Permit2 capture, blind signing, RPC pinning, kill-switch, MCP drift, oracle/slippage, key material.

🧵

[Agentium @AgentiumX]

The ultimate lesson from our certificate analysis: We spent the last decade fixing hardware entropy. We haven’t even started teaching code-writing systems to think like attackers.

If you use an LLM to write security-critical code, it won’t ask you about your target environment. It won't ask if your device is headless. It won't ask about your entropy pool.

You have to force the context. The algorithm isn't where systems fail. The deployment is.

[Agentium @AgentiumX]

Over the past few days, we’ve been posting about a security failure mode that matters for coding agents.

We just published the full writeup, built around a revisit of “Mining Your Ps and Qs.” Key sharing still shows up in modern TLS, but in our data, it looked much more like operational reuse than the old entropy failures.

That’s the point for coding agents. The hard part is not just writing code that runs. It’s anticipating the deployment context where a correct-looking answer quietly becomes the wrong one.

[Agentium @AgentiumX]

https://t.co/NzuLIG34ki

[Agentium @AgentiumX]

https://t.co/NzuLIG34ki

[Agentium @AgentiumX]

The volume of code being written is going up. Human review per line is going down. That trade is fine for failure modes that surface at runtime. Bad code crashes, you fix it, you move on.

It is genuinely bad for failure modes that only surface when the deployment context shifts. Different hardware. Different OS. Different load. No entropy at boot.

Those are the failures cryptographic engineering is built around. They are also the failures agent-written code is structurally most exposed to.

We have not yet figured out how to teach a code-writing system to think like an attacker. Until we do, the deployment context is going to keep being where things break.

[Agentium @AgentiumX]

Largest cluster of repeated TLS certificate keys in a recent CT log scrape: ~24,000 certificates. All on one .dev app-building platform. All sharing a single ECDSA key.

Not compromised. Not recoverable. Just one key reused across a huge fleet of customer staging environments. If that key ever leaks, 24,000 sites become MITM-able simultaneously.

[Agentium @AgentiumX]

The old Linux kernel's /dev/urandom would happily return "random" bytes before any entropy had entered the pool. This was documented behavior. It also caused thousands of embedded devices to use factorable RSA keys, because they all called it at boot.

Documented behavior is not the same as safe behavior.

Just think about how much agent-written code is currently in this category: correct against the spec, wrong against the world.

[Agentium @AgentiumX]

Spent a few weeks revisiting a 2012 paper that found 0.5% of TLS certificates on the public internet had factorable RSA keys.

Pulled 3M+ recent certificates from Certificate Transparency logs to see if it's still happening.
Repeated keys: yes, ~2.2% of moduli. Factorable keys: zero across 11M+ moduli.

The repetition is real. It's just not bad randomness anymore. It's domain parking services reusing one key across 50,000 certificates because it's easier than generating new ones.

[Agentium @AgentiumX]

In 2010, fail0verflow extracted Sony's PS3 firmware signing key. Sony's cryptography wasn't broken. Their random number generator was. They reused the same nonce across signatures, and the private key fell out with a few lines of arithmetic.

The math was perfect. The deployment wasn't.

Many real-world cryptographic disasters look like this.

[Agentium @AgentiumX]

The conversation about agentic security is mostly about what the agent is allowed to touch. It's less often about the code the agent produces. That's the part that should worry us more.

A coding agent will hand you software that runs cleanly in the environment it was tested in and fails silently in the one you actually deploy to. This is not a new failure mode. We've just never had it at this volume before.

[Semiotic AI @semioticlabs]

Semiotic AI and the https://t.co/5edeQujhnW team will be at @AgenticAIFdn's #MCPDevSummit — April 2–3 at the New York Marriott Marquis.

95+ sessions. 50+ speakers. The next chapter of agentic AI starts here.

Register: https://t.co/S5GmWnXThR
#AgenticAI #MCP

[Agentium @AgentiumX]

agentic soul..

[Semiotic AI @semioticlabs]

Semiotic AI has joined the Agentic AI Foundation.

As AI agents move from experiments to production systems, open standards and interoperable infrastructure matter more than ever.

Security and compliance will be foundational to the agentic economy. For autonomous agents to scale, they require a framework of verifiable proofs and robust guardrails that ensure every action is secure, audited, and aligned with global standards.

We are proud to partner with @AgenticAIFdn to build the trusted, compliant backbone of the agentic future.

https://t.co/ErEfwnZytP

[Semiotic AI @semioticlabs]

We're excited to announce that Semiotic AI has joined the @NVIDIA Inception Program!
At Semiotic, we're building Agentium, the secure operating system for enterprise AI agents. We help regulated industries deploy autonomous agents with security, provenance, and cost optimization built in, not bolted on.
Looking forward to working with the NVIDIA ecosystem to accelerate the future of governed AI.
#NVIDIAInception #AgenticAI