Building @ClawQL Agent/MCP as the API and document intelligence platform for enterprises! PlatformEng/SRE/DevOps in a love-hate relationship with Kubernetes.
Los Angeles, CA
Joined May 2016
- Tweets3.2K
- Following494
- Followers846
- Likes3K
Daniel Smith | Building ClawQL Agents retweeted
Another reason this is stupid: a prompt is NOT a guardrail.
“We asked a threat actor to not use curl, and they said they wouldn’t”
This is a solved problem, your runtime container shouldn’t have curl at all, implement egress network rules, readonly fs, gVisor…
Do they know?
While evaluating Qwen3.8-Flash-Next in a controlled sandbox environment, Cohere's research team observed something unexpected.
Asked to generate a defensive cybersecurity detection rule, the model instead inventoried aspects of the machine it was running on and attempted to upload a probe file to an Alibaba Cloud storage bucket in Beijing. Notably, the model's reasoning trace stated that it would not invoke any tools before taking these actions.
Cohere's sandbox blocked the attempt, and no external communication succeeded. We have not determined the root cause, and we are not asserting malicious intent.
But the incident raises important questions for organizations deploying agentic AI systems: Can models take actions that differ from their stated reasoning, and how should security teams evaluate trust, provenance, and behavior in open-weight models?
We are publishing our findings because organizations making model adoption decisions deserve as much information as possible. We hope this contributes to greater transparency, stronger security practices, and continued collaboration across the AI ecosystem.
Read the full report: cohere.com/blog/concerning-b…
Daniel Smith | Building ClawQL Agents retweeted
Introducing AgentReady.org, the first open standard for agent experience.
Agents are a new class of user, but there's still no shared definition of what it takes to be ready for them. So we partnered with the leading companies in the agentic web such as Vercel, Stripe, Auth0, Mintlify, Tavily and Elementor.
Our research lab ran agents on real tasks more than 250,000 times to measure what actually decides whether an agent succeeds, and every requirement traces back to that data.
The result is a short set of essentials in the order agents meet a product: find, read, act.
We've been overwhelmed by requests to join. If you build or study the surfaces agents touch, come help shape it.
The spec: agentready.org
The story behind it: ora.ai/blog/agentready-launc…
Daniel Smith | Building ClawQL Agents retweeted
I'd much rather work with someone who flexes much they accomplished with the fewest amount of tokens vs how many tokens they spent, and I sense this is a major trend in general
How we quantify this as an industry is still TBD, probably a major new set of benchmarks
Daniel Smith | Building ClawQL Agents retweeted
New research from @datadoghq Security Labs! We spent some time poking at Jev to see how we could steer its evaluations.
We found a method that dropped its prompt-injection detection rate from ~83% to ~4% in our tests. We also used the technique to bypass LangChain’s experimental Jev-based tool-risk gating feature. Read more below:
securitylabs.datadoghq.com/a…
Daniel Smith | Building ClawQL Agents retweeted
ICYMI: For the 10th anniversary of "Site Reliability Engineering", we’ve rewritten the definitive Google SRE book! 📖
Featuring brand-new guidance on SRE for the agentic era, modern SLOs, and culture.
Get your copy today: goo.gle/SREbook
Daniel Smith | Building ClawQL Agents retweeted
We're open sourcing SPACE, the sandbox platform that runs every task in Perplexity Computer.
SPACE gives each agent task its own Firecracker microVM and controls credentials and outbound traffic from outside the VM.
Available now under Apache 2.0: github.com/perplexityai/SPAC…
Daniel Smith | Building ClawQL Agents retweeted
My dear friends, I’d like to show you my latest toy project
Introducing Handwired: turn your regular JavaScript code into a neural net!
- no training
- exact outputs vs the JS program
- fully differentiable
All runnable in a browser, without GPU
Daniel Smith | Building ClawQL Agents retweeted
try pstack! it’s my personal set of skills for rigorous and autonomous engineering with agents. it’s updated frequently as I continue to tune and simplify them
10 second tutorial:
1. run /setup-pstack and choose your budget
2. add /poteto-mode in front of any prompt you want done rigorously
3. ask /poteto-help whenever you’re unsure what pstack skills to use
4. that’s it!
Grok Bot: x.ai/bot/plugin/9717366
Cursor: cursor.com/marketplace/curso…
Source: github.com/cursor/plugins/tr…
Daniel Smith | Building ClawQL Agents retweeted
okay now that we're past that tired discussion, let's talk about how we get agents to write more correct code (note: this won't mean the code will be Good, but it should at least work)
this is the entrypoint into your most basic agentic loop: verification. it means giving your agent the ability to verify its own work, most commonly by actually running and interacting with it like a real user would. whether your interface is a cli/api/ui/whatever, you want to start here so that your agents can close the loop. if you want you can even have your agents model the problem in TLA+ and attempt to verify if you have things like state machine bugs.
the point is to give yourself confidence in the agents' work by them producing some kind of artifact that proves that 1) that the work is correct, 2) that it matches what you intended, and 3) is easier to review than reading the whole PR. most commonly this would be a video and/or screenshots for UI work.
everything else like skill packs are really bonus and optional, all you need is a way for your agents to verify their own work to start using them more autonomously. some caveats are that not all domains can be verified easily yet, and that verification is just approximation and can still be wrong. it's no different than trusting that a human actually ran the code they wrote and trusting it
so start here!
pstack now includes 2 skills i recommend everyone use or copy:
/create-verification-skill
github.com/cursor/plugins/bl…
/maintain-verification-skill
github.com/cursor/plugins/bl…
if you don't already have one, /create-verification-skill creates a skill that teaches your agent how to run, control, and debug your app.
it also creates something i call the feature map: a map of all the features in your app and how to get to it and use it from a user's pov. it allows agents to navigate and use the app just like a real user which greatly increases its ability to verify its own work. but of course, this feature map goes out of date very quickly.
run /maintain-verification-skill as a daily automation with cursor cloud agents. this skill will check your app for changes and keep your feature map up to date.
having a strong verification skill will end up becoming critical infra for your team and become the foundation of boosting everyone's productivity and quality and also enable more interesting automations to be built.
install cursor.com/marketplace/curso… and you'll get auto updates for my skills. enjoy!
Daniel Smith | Building ClawQL Agents retweeted
i feel like swe interviews could probably collapse into just 2 technical rounds:
• system design (how well can you articulate your ideas, do you actually know how to engineer something)
• onsite project to build a real thing with agents (can you translate your intent into high quality outcomes)
everything else we used to ask is no longer necessary
🗞️ if your team is too busy doing their 'normal job' to experiment with AI, you're preparing them to be replaced
ghuntley.com/replaced/
In this post, I guess this's the last time I'll say it. AI use is no longer optional if you wish to be employed. What follows is advice for current employees and hiring managers on how to hire in 2026 to source AI-first candidates.
Daniel Smith | Building ClawQL Agents retweeted
Introducing gdp-ts: Ghosts of Departed Proofs for TypeScript.
gdp-ts is a library, linter and AI skill for safer API design. Under this contract, sensitive functions require 'proofs' that the caller performed an authorization check.
The typechecker verifies these proofs at compile time, preventing your team and agents from shipping catastrophic security (and other kinds of) bugs.
While these patterns have existed for quite some time, especially in ecosystems like Haskell, ① human code review and ② cognitive and syntactic overhead made these solutions niche.
The situation is now inverted. Agents are writing more code than we can review, and they *thrive* in tight loops with hard constraints that would frustrate us. We see this with the rise of Rust, borrow checker, code aesthetics debate and all.
The README and examples model a real-world Vercel API product constraint: changing the password on a Project requires a proof of a certain role + a certain entitlement. Thanks to Matt Noonan and Ollie Charles for their research in this space.
github.com/rauchg/gdp-ts
Daniel Smith | Building ClawQL Agents retweeted
i feel like people do not grok how important celld is.
it's scalable applications of arbitrary complexity. the only dependency is s3.
once you see it, you'll realize there's no point to traditional javascript runtimes in serving applications - only for build processes (eg bundling) and scripting.
the networking and scaleability are deeply rooted not only in the distributed runtime (celld), but in the programming model itself (largely kenton's design)
I wasn't quite sure when I started celld how well this could be made to work, but we've been running it in bigger capacities and getting user reports over the last months. Actually handles load surprisingly well. (any experience in the comments to share?)
because the programming model does not expose the underlying linux system, you can actually think of celld as a distributed operating system - running in user space of linux. it only runs one program / doesn't support multi-tenant, but it has system services like an operating system. it's all about networking - i like to think of it as the practical modern version of plan9 or even erlang beam.
Daniel Smith | Building ClawQL Agents retweeted
“Noooo you don’t get it if we want to train the models they need unrestricted access to the internet, that’s why it’s hard”
Okay why wasn’t monitoring running
“Noooo you don’t get it that’s because execs decided not to so they could go faster”
Daniel Smith | Building ClawQL Agents retweeted
Effect v4 is here.
One ecosystem. Zero dependencies.
The next chapter of Effect and the foundation for building reliable software and AI agents in TypeScript.
ALT Effect 4.0 stable release announcement on a dark background. Large white “4.0” above “Production-ready. Out now.” A timeline along the bottom progresses from 3.0 Stable to 4.0 RC to 4.0 Stable.
Daniel Smith | Building ClawQL Agents retweeted
It is apparent that cybersecurity people are not the target audience of what the labs publish about cybersecurity.
They instead are weaponizing these narratives as fearmongering for non-security people, which would react to this very differently.
Excluding the experts from what you are writing about is very concerning.
Daniel Smith | Building ClawQL Agents retweeted
AI safety people discovering that a system can emit petabytes of logs: “this is an unprecedented observability problem. we may need fleets of agents to reason over all this data.”
old infra guys:
brother, we were processing PB-scale telco CDRs, signaling traces and network logs on a Tuesday with Hadoop.
dump it into HDFS. partition by day/site/whatever poor bastard needed the report. write some Hive that compiles into an offensively large MapReduce job. let YARN distribute the suffering. wait for the shuffle. discover one reducer has 40% of the keys. swear at data skew. fix it. run it again.
if a node dies, Hadoop runs the task somewhere else.
if twelve nodes die, Hadoop gets more enthusiastic about it.
our “agentic observability platform” was Grafana, grep, awk, a shell script written in 2012, and one senior engineer staring at reducer 317 stuck at 99% saying “that’s not fucking normal.”
PB of logs is not scary.
we had standards.
Daniel Smith | Building ClawQL Agents retweeted
Don't use this
Build your own software using their tokens
So when their tokens become too expensive
You can switch to your own GPUs
Your compute. That you control
So you yourself can't be controlled
You need to control your stack -- or you become enslaved
