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.
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.
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.
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.
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.
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 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
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
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
@yilmaz99719@graphprotocol Odos is a separate entity with its own dev team. Project incubated in Semiotic and spun out 2+ years ago. This announcement has no impact on Odos.
After almost 5 years of collaboration, Semiotic AI has concluded its core-dev engagement with @graphprotocol.
We're proud of our contributions to The Graph ecosystem, including pioneering work in AI for decentralized indexing, query micropayments, and cryptographic research.
All code developed under the grant has been open-sourced under Apache 2.0 license and remains available to the community.
We're excited about what's next for Semiotic and grateful for the opportunity to contribute to The Graph Network's growth.🚀
Highlighting this again. The Graph’s Token API release shows how AI improves spam detection across seven chains by processing both onchain and offchain signals. A meaningful upgrade for anyone building with NFT data.
We needed a production-grade Rust SDK for @circle's CCTP to run cross-chain USDC flows at scale, so we built it.
cctp-rs has quietly been powering millions in cross-chain USDC transfers inside Semiotic. We’ve now put together the full write-up on why we built it and what we learned.
Link below.
Excited to have driven the work behind GraphTally. You can learn more about the protocol and proposed optimizations on our blog:
https://t.co/F3rCqpS2Bu
The Graph’s GraphTally already implements microtransactions directly at the protocol layer.
x402 simply standardizes that same concept for the broader web, but now it’s machines handling the payments instead of users.
That’s what unlocks broader scalability across web3.