New week, new Rust! What are you folks up to?
(PS.: Sorry for the delay, I had a flight from San Francisco to Frankfurt for most of the day).
I've been doing more work on my vaguely DCE-inspired middleware.
I have posts (unidirectional messages), and requests (request/reply), put stream (upload a stream a data to server), get stream (get a stream of data from server) and io stream (combined get and put stream) working.
I have both plain TCP and TLS (using rustls) connections working. I usually make the TLS library an implementation detail, but this time I tried something new: I'm intentionally leaking the TLS implementation to the application. Not sure how I feel about it yet, but I'll give it a chance.
Currently working on graceful shutdown of connections.
I've been doing some benchmarking, and the core communication library is pretty fast for large frames, but many tiny ones are abysmally slow. I think I know why, but I need to verify my hypothesis. If the reason is what I think it is, then I have a solution for it.
Actually got far enough to be able to start writing applications for it, which is quite neat. I don't have authentication and authorization implemented yet. My goal is to allow application-defined schemes, and I've sketched on a solution that I think will be able to cover most schemes out there.
Also realized how I could massively optimize a deduplication storage library I've been working on. It's not often I can make an algorithm simpler, use far less ram, avoid using the filesystem for temporary storage, and also be much faster -- all at the same time. Although I haven't actually implemented it yet, I'm certain it will work.
Last week was good, and it's looking pretty good for this one as well.
Still working on uutils AWK, a modern gawk reimplementation as a performant bytecode, register VM. It is human code and blazing fast. We'd like some new hands! Let me know if you'd like to contribute 
This week we tackled the rest of array operations, and I'd like to finish our regex layer over BurntSushi's excellent regex-* crates. Getting our sans-io layer fully sketched out and prototyped is next, as well as cheap, concurrent reentrancy on the VM via bespoke hacks of the AWK language.
Let me know if you want me to rant about any details!
Been working on agentflow — an AgentOps stack for Rust agents built on top of graph-flow. It's nine independent crates bundled under one, each covering a different piece of running agent graphs in production:
- orchestrate — token-level streaming, dynamic map/ensemble tasks for graph-flow
- guard — validators + retry-until-valid on LLM output
- act-guard — policy-as-code for what an agent is about to do
- validate — schema validation for Polars DataFrames
- evaluate — graded-score eval suites
- checkpoint — snapshot/rollback a task's Context
- trace — latency/tokens/cost per task, no OTel needed
- cache — exact + semantic response caching
- remember — long-term memory (retrieve/inject/extract/resolve)
Each works standalone via cargo add, and a few of them (checkpoint/trace/cache/memory) are plain graph_flow::Task wrappers so they just stack by nesting.
Would love feedback from anyone building agents in Rust.
I added a small optimisation to pstd ( Crate with parts of Rust std library ( different implementations, features not yet stabilised etc )) to eliminate panic-handling code when panic is set to abort.
e.g. here