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
- Followers844
- Likes3K
Pinned Tweet
mcp-grpc-transport is now on npm (v0.1.0).
Pluggable gRPC transport for MCP that supports:
- Full protobuf surface (ListTools, CallTool, streaming ops, pagination, cancellation)
- Bidirectional Mcp.Session stream (NDJSON compatibility)
- gRPC health checking + optional server reflection
- TLS/mTLS via env vars
- Interceptors and custom options
This is the transport many teams have been waiting for, especially those already running gRPC microservices.
If you’re building production MCP servers and already operate in a gRPC-heavy environment, this should feel like a natural fit. It also pairs excellently with unified MCP servers that embed optimized internal layers (like GraphQL proxies for token efficiency).
Installation & basic usage is straightforward (see code snippet in comments or npm page).
One-liner integration via maybeStartGrpcMcpServer({ createMcpServer }).
Perfect drop-in for teams tired of JSON serialization overhead or wanting native mesh routing.
Docs & examples on the npm page. Built as part of the ClawQL stack but completely generic.
Try it with ClawQL (now unified single-process) or your own MCP server. Feedback, issues, and contributions welcome.
Repo: github.com/danielsmithdevelo…
npm: npmjs.com/package/mcp-grpc-t…
Feedback, bug reports, and PRs are very welcome. Let’s make MCP even more cloud-native and production-ready together.
#MCP #gRPC #AI #AgenticAI #TypeScript #Kubernetes #EnterpriseAI
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…
clawql.com/benchmarks
If you think you can beat @ClawQL then certainly give it your best shot 💪
We will keep benchmarking more and more harnesses / gateways against us and publishing all results and scripts so everything can be repeated and verified
Governance 🤝 efficiency
why does security matter so much to us? And token efficiency?
Because we’re meant to be your gateway to production. We’re the layer that gives you the confidence to ship.
Whether it’s inference gateways for agents that build traces for finetuning or full document pipelines. Whether it’s giving your agent isolated sandboxes or letting your entire team build and contribute to the shared memory and company ontology.
@ClawQL brings its security and efficiency to all of it and gives you the foundation you need to succeed cheaper and quicker than you did before.
Plus when I say we take security seriously, I really mean we take security seriously.
We follow defense in depth strictly and maintain a zero trust approach to security. Every single image we ship is hardened, scanned, and only then signed if no issues are found.
Kyverno enforces this at runtime and both Panguard and OpenAPPA secure the runtime inference calls themselves against injection and other attacks.
Talon plus Falco ensures no chance of escaping and instant quarantine if they do. Then our mandatory audit log and observability stack proves nothing gets missed or tampered with.
We fail-closed when we cannot guarantee these requirements. Security first always.
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
if you squint just a little bit Cloudflare DOs are not unlike Erlang/Elixir processes...
...and this sort of makes the Cloudflare platform like a planet-wide BEAM cluster.
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.
Zero trust is the truth. Zero trust is the light. Defense in depth gets undermined quickest by the senior admin that refuses to give up personal direct control over the systems he’s responsible for. Do not trust others. Do not trust yourself. Build your process with that in mind.
This is very cool and will likely make its way into @ClawQL temporarily. In fact we will likely be adopting some of its features with our own version we’re building on top of celld by @rough__sea with the hopes of making it survive restarts and to integrate our audit trail to it.
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.