Hemant

Principal Engineer @Aruba-a HPE Company | ex-Meesho | Interested in Databases & Distributed System | Rust & Golang

[Hemant @Hemant2184]

@tonboio Nice. 👍🏻 ship it.

[Hemant @Hemant2184]

Agents' context is fragmented across systems in enterprises: SaaS applications, doc stores, transactional and analytical databases.

This is a big hurdle in successful deployment of agentic systems.

The way I see it, there are two paths forward:

First, build integrations so the agent can talk to these legacy systems.
But here is the challenge, agents operate differently than humans. For a single task, multiple agents might run parallel hypotheses, iterating at extreme speeds. This creates short-lived, massive spikes in traffic. Can legacy systems handle this kind of bursty traffic?

Second is a single system, a unified layer which caters to agentic workload -performant at agentic scale.

This presents an awesome opportunity to build data infrastructure for agentic scale.

#DataInfrastructure #AgenticAI

[Hemant @Hemant2184]

@almoggavra @redixhumayun I have the same question. In my view, like humans, agents will have use cases with relaxed latency requirements. This is true even in case with advancements in technology the LLM APIs become faster or locally hosted small models have faster response times.

[Tzu Gwo @yochowgwo]

- Open-source self-hosting.
- sub-50 ms P99 latency
- Plain S3 economics, no S3 Express tier
- Quorum-replicated durability and horizontal scaling based on thread-per-core x multi-Raft

That's how we implement this: https://t.co/L3WxDkvXuR

[Almog Gavra @almoggavra]

[1/5] you can build provably correct systems using only object storage, but it requires some care to get the protocols right.

🧵 Summarizing my new post:
https://t.co/8UO2ZkYyPV

[Pekka Enberg @penberg]

We built a database system on S3 Express, and I wrote a book about latency, so let me comment on some of the technical details.

When we talk about write latency in a database system, the limiting factor is typically the time to commit to durable storage. If you are using object storage as your backing store, you have two options for the write path, depending on your durability model. The first option is to write to the object store asynchronously, which means object storage is irrelevant to your write latency, and therefore, uninteresting when comparing S3 Express and NVMe latency.

The second option, which is what we actually do, is that you write to S3 Express synchronously, and now your commit latency is bound by it. In other words, when a commit needs to become durable, we perform a PUT request on S3 Express as a replacement for a `fsync()` call on NVMe. In other words, if the PUT request succeeds, your commit is now durable on S3 Express, just like with `fsync()`, it's durable on disk. (Of course, you often want replication to multiple disks, but you can parallelize that, and it does not change the scenario very much.)

In this scenario, we can meaningfully compare NVMe and S3 Express latency: NVMe has up to 100x lower latency because enterprise-grade NVMe latency is in the tens of microseconds, whereas S3 Express latency is in the single-digit millisecond range. Of course, depending on your database architecture, you may also see additional latency from networking, but there is no scenario where object storage has lower latency than NVMe.

Of course, there are many other advantages to building on top of object storage. For example, high availability, elastic storage scaling, cost-efficiency, and, in my opinion, competitive latency for many use cases. But we're talking about just pure write latency; S3 Express is clearly not faster than NVMe.

[Apurva Mehta @apurva1618]

This is the way. I think infrastructure that can be directly manipulated and managed by agents will win.

I'm betting that the logical end state is Your Agent + Cloud account, since that's the path of least friction.

https://t.co/fJUUcoRNLv

[Ben Warren @bwarrn]

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.

[Aditya Agarwal @adityaag]

I cannot explain how awesome this is.

[JER @lifeofjer]

https://t.co/ofucbVgkLV

[Viacheslav Biriukov @brk0v]

🦀 Rust: Tokio + Rayon is not automatically a performance win.

Excellent real-world lesson in async + CPU-bound work in production: thread oversubscription, CFS throttling, and p99 latency spikes into seconds.

https://t.co/pxXfpqNyuR
#rust #rustlang

[Werner Vogels @Werner]

For two decades, S3 has been an object store, but today it's something broader. S3 Files lets you mount any bucket as a filesystem—no copies, no sync scripts, no choosing between file and object. @andywarfield tells the full story, including the "filerectories" that almost made the cut. https://t.co/zrkLOZS5Qe

[Vivek Galatage @vivekgalatage]

The question: "Why do CPUs have multiple cache levels?" often gets many CS students and professionals thinking and researching.

This article from Fabian Giesen narrates a "cache story" in a relatable way, only to delve into the details - a must-read!

https://t.co/RyhpjqAEhX

[Debasish (দেবাশিস্) Ghosh 🇮🇳 @debasishg]

an attempt to unify domain modeling with data oriented design - domain API (the ubiquitous language) at the edges and DoD as the implementation.

Bridging Domain-Driven Design with Data-Oriented Performance, brought to you by the power of Rust procedural macros -

- #[derive(SoA)]
- #[derive(SoAStore)]

An example app included in the project using domain friendly APIs, with the macros hiding away all the DoD machinery. The basis of the approach is that users write familiar domain code, but the macros generate highly optimized SoA implementations with multiple access patterns - all without any runtime copying or allocation overhead. The Rust type system ensures memory safety through lifetime tracking of the view references.

Still a WIP, but some very interesting benchmark results (run for yourself):

- cargo bench -p example_app

(Github link: 👇)

[Debasish (দেবাশিস্) Ghosh 🇮🇳 @debasishg]

Playing around with this .. Rust macros for the win. DDD at the edges, DoD as the implementation.

Some very interesting benchmarks ..

Clearly demonstrates that cache behavior trumps theoretical advantages. SoA's sequential access wins when you need few fields, but AoS's spatial locality wins when you need multiple fields from the same logical record.

[Andrew Lamb @andrewlamb1111]

BTW if anyone wants a good intro to database storage / Log structured storage (aka LSM trees), the @CMUDB lecture this fall is a good one: https://t.co/ln6Yi0K1JZ

[Abhinav Upadhyay @abhi9u]

System calls are the interface between the user space and the kernel. They are needed for fundamental things like reading a file, and making a network call. But they are also very expensive because they need to do things like saving/restoring registers, page table, stack.

More importantly, they also make the user space code slow after return from the kernel, and this can be more costly. This happens due to the loss of the microarchitectural state of the process, such as instruction pipeline getting drained, branch predictor buffers getting flushed, etc.

In my latest article, I talk about this in detail. The article shows the Linux kernel code which handles system calls and breaks down the performance implication of each step the kernel takes.

It is more complicated and nuanced than I can describe here. For example, the performance of newer hardware and kernel might be better than the older ones. And it is not the same across all hardware vendors (e.g. Intel vs AMD). So, check it out.

Link is in the replies.

[Andy Pavlo (@andypavlo.bsky.social) @andy_pavlo]

Monday Sept 22nd is the start of @CMUDB's new seminar series: Future Data Systems
@SamArchDB + @pateljm + I are hosting speakers building vanguard datalake / lakehouse systems.
Mondays @ 4:30pm ET via Zoom. Open to the public. Videos posted to YouTube: https://t.co/yv1XkGc5jw

[shikhar @shikhrr]

We open sourced a read-through cache for S3, called Cachey https://t.co/6mWV2tYAyP

[Hemant @Hemant2184]

@iavins Setsum on the operations and compared over the full list(checkpointed). Read recently about this how Chroma uses it in wal3
https://t.co/McmrW8GICh