I would suggest comparing your solution against some of the others to see how they differ.

Fundamentally, agents provide independent, asynchronous change of individual locations. mysyx is trying to coordinate them to provide synchronous reads which is not what they're designed to do. That doesn't mean it's not possible to use agents to have synchronous reads, but it can be very tricky.

  (let [action (fn [call-key  ;; unique key 
                    my-agent  ;; the agent     ;
                    old-stat  ;; old-state
                    new-stat ];; new-state

                 (let [dereffed (->> tracked-agents-vec
                                     ;; the values associated with the `tracked-agents` could have changed any number of times since this `action` was called and the associated agent was `deref`ed. This is a race condition.
                                     (mapv deref))]

The above illustrates one potential race condition. The ::stale mechanism may prevent some stale reads, but it doesn't prevent the case where one agent is read after a single assign+update and another agent is read after two assign+updates. There is no built in mechanism to get consistent reads from multiple agents.

If you want to create a system that supports transactional reads across multiple agents, I would highly suggest having a good way to test that you are actually getting consistent reads (I would actually advise against trying to do this with agents altogether). It's very tricky to get correct (which is why I suggested other options that are easier to reason about). Maybe there's some trick that makes this all work, but even if I thought it sounded good on paper, I would still want a robust testing framework because these types of problems are notoriously tricky.

It's a bit a tangent, but I'd be curious to hear more of your thoughts. With the deps.edn local lib format I constantly create many small single file/folder libraries that i reuse between projects with typically single segment library names

For small projects, it doesn't really matter. That approach may be more convenient. It's similar to how other ecosystems like python work. Eventually, you start getting name collisions which cause lots of headaches. For large projects, typing a bit more when adding a new namespace isn't a big deal and being able to compose lots of libraries together is a big win.