Ha I literally use ASD-STE in a hook I built for exactly this reason github.com/Peterrallojay/cla…
We'll be spending a lot more time trying to understand the outputs of language models. A few thoughts, tips & tricks:
Writing. Something I've had success with: Ask your LLM to explain something in ASD-STE100, it's a controlled language specification originally developed for aerospace maintenance documentation. LLMs well-versed in this language and it comes with heavy constraints on clean writing style that I often find a lot more readable. Sometimes I've tried to soften it a bit e.g. ask for "80% of the way to ASD-STE100" because the spec is quite stringent. But even better:
Diagrams / images. Instead of writing, ask your LLM to create a diagram. These can be a lot easier to process, parse, and understand. But even better:
Web pages. Ask for output "in HTML" to get a beautiful, interactive webpage. LLMs are getting really good at frontend and can create beautiful experiences, animations, etc. But even better:
Explainer videos. The output format I am most bullish on is fully custom / bespoke explainer videos generated on any arbitrary topic. Experiment with things like "Create a 3b1b style video explainer on X. Use my ElevenLabs API key for audio narration". (you'd need an API key for the latter or you can ask your LLM to find you decent free alternatives that use your local compute). This is actually starting to work!
In summary:
- As LLMs get better, they will do more and more of the legwork autonomously, and a lot more of our work will rise up the abstractions into oversight and understanding.
- Luckily, LLMs can help here too because as intelligence and code are increasingly abundant, you can ask for large, custom, discardable software artifacts (e.g. web apps, video explainers) that would have never made sense to create before. Push the boundaries here and you'll be surprised.
pete retweeted
Jev & DuckDB: Plain-English Conditions in SQL 😎 🦆
Say you have a Parquet file of 50,000 support tickets and want to know which customers are angry. A `LIKE` pattern won’t find that.
The usual options are to label data and train a classifier, or to send each row to a chat LLM and parse the text it returns. The first takes work up front. The second is slow and costs more per row.
Jev – introduced by TypeSafe AI earlier this month – is a model that answers this kind of question with a typed value and a probability instead of a paragraph. Since then, a number of #DuckDB community extensions for Jev have been published that let you filter, classify, and score DuckDB rows with plain-English conditions.
This post covers what Jev is, how the extensions work, and where to learn more: duckdb.org/2026/09/29/jev?ut…
#Jev
pete retweeted
Vmax is building an open-ended learning system that generates and optimizes itself on tasks that it creates, avoiding human bias that may corrupt optimal learning curricula.
In PopuLoRA, we instantiate this as co-evolving populations of LLMs performing asymmetric self-play.
pete retweeted
What is HQ 👇
“Team AI is the next challenge.”
@jacob_posel on HQ’s opportunity:
“The biggest problem with AI right now is everyone is just doing their own things on their own computers. It’s siloed. It’s fragmented.”
One person on your team creates a great skill. It lives on their laptop. No team-wide adoption.
HQ is the shared context layer that fixes it.
truth.
> This means you'll be able to build on Claude without needing an API key!
you already could use the agent SDK with a max plan, the ToS was unclear and lots of folks like Conductor were doing this
I am 100% supportive of anthropic restricting usage of its product and inference however it wants to
But messaging this as "you can now do X" instead of "hey we're seriously restricting how you can do X" is gaslighting
pete retweeted
Introducing HQ: the AI operating system for your company.
HQ lets your team share knowledge, skills, workflows and API access across the organization, so everyone works from the same foundation.
Team AI is still messy, and hard.
Individuals work in silos. There is no consistent knowledge base. Teams end up with 10 versions of the same skill, all performing at different levels. One person becomes 10x more effective, while everyone else is left trying to catch up.
HQ makes this simple.
Built on top of Codex and Claude Code, HQ sits directly inside your existing workflow. It helps manage your company's context layer, share skills, standardize workflows and control access, so people only see what they need to see.
We built HQ internally to solve a real problem. We use it every day. It has been incredible for enabling our power users, but just as importantly, it has helped the least technical members of our team become incredibly effective AI users.
HQ turns one person's breakthrough into everyone's baseline.
It is a powerful, elegant tool, and we are incredibly excited to share it with the public.
Book a demo below.
well said
This is really well thought out.
Filesystems are the new default abstraction for agents to interact with documents (the new RAG stack in 2026). The issue is actually figuring out how to productize this; you can't "productize" Claude Code over a local file system.
Seems like this tool has all the semantics of filesystems with the versioning of git
pete retweeted
Imagine you're building a legal-tech agent that drafts LOIs, redlines contracts, and coordinates signatures.
You grab a harness, spin up a sandbox, and within a day you hit a wall:
– How do documents persist when the sandbox dies?
– How do you control which files an agent can read vs. edit?
– How do humans review and roll back changes?
Swap real-estate docs for case files, claims, audit reports, or pull requests — same problem.
A new agent stack is forming.
> Models handle intelligence.
> Harnesses handle orchestration.
> Sandboxes handle isolation.
The missing layer is storage — and existing solutions weren't designed for agent workloads.
So we built Mesa: a durable, POSIX-compatible filesystem with built-in version control, designed from the ground up for agents.
It supports isolated branches so agents can work in parallel without locks.
Sparse materialization of files means massive document sets load instantly.
Fine-grained history so every change is reviewable and auditable.
Design partners are already running it in production across legal, healthcare, GTM, business ops, and coding agents.
Private beta is open. If you're building enterprise agents that touch long-lived documents, join us 👇
pete retweeted
This is a good idea.
Introducing Mesa: the most powerful filesystem ever built, designed specifically for enterprise AI agents.
Every team building agents eventually hits the same wall: where do the files live?
Not the chat history, the actual artifacts the agent works on.
> The contracts your agent redlined
> The claim files it updated
> The 200-page audit report it edited overnight while you were asleep
Today those documents live in a sandbox that dies in 30 minutes, an S3 bucket where concurrent writes clobber each other, or a GitHub repo that was never built to absorb agent-scale traffic.
So we built Mesa.
The world's first POSIX-compatible filesystem with built-in version control, designed from the ground up for agents. You mount it into your sandbox like any other filesystem. Your agent reads and writes files normally. Behind the scenes every change is versioned, branchable, reviewable, and rollback-able — like a codebase, for any file type.
Mesa provides
– Branches so agents work in parallel without locking
– Durable storage that survives sandbox death
– Sparse materialization so massive document sets load instantly
– Fine-grained access control per agent
– Full history for human review and audit
Design partners are running Mesa in production across legal, healthcare, GTM, business ops, and coding agents.
Private beta is open: link in the comments
pete retweeted
I'm so excited to officially share what we've been cooking up at Mesa: the most powerful filesystem ever built for AI agents.
The dirty secret of every "production" AI agent today: the filesystem is held together with duct tape.
Teams are stitching together S3, GitHub, sandbox-local disks, and homegrown diff logic to give their agents something resembling persistent, versioned storage. None of it works.
S3 isn't designed for parallel agents - concurrent agent writes silently overwrite each other.
GitHub has the semantics but rate-limits you into the ground at agent scale and doesn't give you filesystem ergonomics.
Sandbox disks vanish the moment the container dies.
And your agents don't want to git clone and git push anyway. 𝗧𝗵𝗲𝘆 𝘄𝗮𝗻𝘁 𝘁𝗼 𝗿𝗲𝗮𝗱 𝗮𝗻𝗱 𝘄𝗿𝗶𝘁𝗲 𝗳𝗶𝗹𝗲𝘀. 𝗟𝗶𝗸𝗲 𝗲𝘃𝗲𝗿𝘆 𝗽𝗿𝗼𝗴𝗿𝗮𝗺 𝗲𝘃𝗲𝗿 𝘄𝗿𝗶𝘁𝘁𝗲𝗻.
So we built the missing layer.
Mesa is a durable, POSIX-compatible filesystem with version control built in. Branches, diffs, history, rollback, access control — every primitive a codebase has, for any file type, at agent scale. You mount it. Your agent uses it like a normal filesystem. We handle the rest.
Private beta is live. Link in comments.
pete retweeted
Introducing Mesa: the most powerful filesystem ever built, designed specifically for enterprise AI agents.
Every team building agents eventually hits the same wall: where do the files live?
Not the chat history, the actual artifacts the agent works on.
> The contracts your agent redlined
> The claim files it updated
> The 200-page audit report it edited overnight while you were asleep
Today those documents live in a sandbox that dies in 30 minutes, an S3 bucket where concurrent writes clobber each other, or a GitHub repo that was never built to absorb agent-scale traffic.
So we built Mesa.
The world's first POSIX-compatible filesystem with built-in version control, designed from the ground up for agents. You mount it into your sandbox like any other filesystem. Your agent reads and writes files normally. Behind the scenes every change is versioned, branchable, reviewable, and rollback-able — like a codebase, for any file type.
Mesa provides
– Branches so agents work in parallel without locking
– Durable storage that survives sandbox death
– Sparse materialization so massive document sets load instantly
– Fine-grained access control per agent
– Full history for human review and audit
Design partners are running Mesa in production across legal, healthcare, GTM, business ops, and coding agents.
Private beta is open: link in the comments
pete retweeted
Had an awesome time at the @daytonaio Compute conference!
Some interesting takeaways from the sessions and conversations...
1. The OpenClaw moment opened people's eyes to how much AI can do outside of just coding. Everyone from startup to enterprise scale is now figuring out how to run more agents & give them data access in a secure way.
2. The paradigm for top agents is: run an agent in a sandbox with access to a filesystem. This lets agents flexibly compose workflows using files, bash, Unix utilities, and code execution. Frontier models are heavily trained on these primitives.
3. Virtually everyone needs a few core pieces of infra for their agents: A harness (ex. Claude Code), a sandbox/VM (ex. @daytonaio), a durable filesystem (ex. @mesa_dot_dev), and often a secure MCP gateway (ex. @mint_mcp)
4. The AI space is moving faster than ever. New techniques emerge every month, and the best companies have to pay attention to stay ahead of the curve.
We're excited to continue partnering with leaders like @ivanburazin, @JukicVedran, and @gorandraganic to push the frontier of AI.
If we didn't have a chance to connect at the conference, feel free to shoot me a message. Always excited to riff on the latest & greatest techniques for building & running agents!
$15 for a code review… or try a code review that runs as you code.
-uses your existing harness (Claude code, codex, or Gemini)
- no api keys
- fully local
- open source:
github.com/mesa-dot-dev/code…
