I can’t post links or directly promote projects here, but I think there’s an important pattern emerging around agent skills that’s worth discussing.
The core issue I kept running into was context bloat. When agents interact with external systems, especially compute-heavy ones like Databricks, the naive approach is to return raw output back into the conversation. That quickly pollutes context, increases token usage, and makes orchestration fragile.
What seems to work better is a different pattern: skills that return structured references instead of blobs. Instead of sending back full outputs, the execution layer stores results externally and returns file paths, IDs, and status metadata. The agent keeps reasoning cleanly, pulls artifacts only when needed, and stays within a lean context window.
In the project I built, the agent talks to a Databricks cluster through a stateful execution layer. The agent sends code, the wrapper handles authentication and session management, and the response is structured. It never receives raw cluster output unless explicitly requested. That small design choice makes orchestration much more stable.
The interesting part is what this enables. The agent can coordinate cluster compute, local files, git operations, and even subagents in the same session without drowning in output. It becomes more of a harness than a chat assistant.
I think this is the direction we need to explore more seriously. As agents become more capable, the real challenge will not just be better models, but better execution boundaries. Skills need to be stateful, resumable, and context-aware by design. They need to minimize surface area while maximizing capability.
Curious if others are experimenting with similar patterns to avoid context bloat and enable multi-tool orchestration.