"Each conversation is writing an invisible roadmap you need to materialize". 100%. Most teams treat observability as a checkbox, not a product feedback loop.
Interesting take on building your own orchestration layer. What's the core advantage you're seeing with Adama over existing frameworks? Curious if you've hit any walls with reliability or if the control trade-off is worth it.
Really like the framing of "Time to Accountability" as the bottleneck. Curious how you think about this for the orchestration layer specifically. A lot of agent frameworks give you observability into the graph. You can see which node fired, what tools were called. But the reasoning that led to those decisions is still opaque. Is the answer better tracing/logging of model decisions? Or more constrained orchestration logic?
Cost attribution gets even worse when you factor in the bad decisions. Retries, abandoned tool calls, and cascading failures that still hit your bill but never show up in traces.
The 'you can review code you can no longer write' line is so real. That's the gap that sneaks up on you. Easy to miss until you're three layers deep in something you merged last week.
Context compression is necessary but it's treating symptoms, not the disease. The core issue is that most agent architectures bolt long-horizon reasoning onto models that weren't designed for it. Summarization, filesystem offloading, etc. are clever workarounds, but you're still fighting the model's tendency to lose the thread. Curious if anyone's seen approaches that handle context at the inference layer rather than patching it in the orchestration layer.
Interesting approach. Curious how you think about the tradeoff between external memory systems vs. models that manage their own context natively. It feels like the industry is split on which layer should own this.
Solid survey. The breakdown of in-context vs post-training reasoning is a helpful lens. Curious to see how the "long-horizon interaction" challenges they flag get addressed in practice.
Interesting approach. Progressive disclosure helps with token limits, but I'm curious how you handle state across multi-step tasks where Layer 2/3 context from an earlier step becomes relevant again later?
The "lost in the middle" problem is also about the model losing track of what happened 10 steps ago even if it was loaded at the time.
The sub-agent context isolation tradeoff is real. We've been experimenting with pushing context management into the runtime itself, with the model deciding what to keep, what to prune, what to pull back in, instead of manually feeding context as parameters.
We've been working on a similar problem, but went the route of pushing this into the model and runtime layer instead of the orchestration layer. Less scaffolding, more baked into how the model reasons. Happy to share more if useful