Chetan Conikee
Chetan came through financial systems, trading infrastructure, and computational neuroscience—places where action, evidence, and accountability have to agree.
Say hello on LinkedIn ↗We came to agents sideways.
Through programming languages, financial protocols, distributed traces, and the study of how systems learn. Different fields kept bringing us back to the same question: how does intent survive contact with execution?
language→protocol→trace→learning
What should a machine remember after the work is done?
An agent can reason beautifully, use the right tools, correct itself, and finish the job. Then the session ends. The result remains, but the useful path through the work is usually lost.
We had seen versions of that problem before. Each of our earlier fields supplied a different piece of the answer.
First, give intent a language.
Programming languages taught us that reliability begins before execution. Types, constraints, and semantics make intent explicit enough for a machine to act on—and make invalid work difficult to express.
Compilers also taught us that translation matters. What a person means has to survive every layer between source and machine without becoming a suggestion.
Then let meaning cross a boundary.
Financial networks, trading systems, and distributed runtimes taught us the next lesson: useful work rarely stays inside one process. It crosses organizations, machines, identities, and failure domains.
A protocol earns trust by being precise about state, ordering, authorization, retries, and what happens when the other side does not answer.
Keep evidence of what actually happened.
The specification is not the execution. Distributed tracing and OpenTelemetry taught us to follow the real path: which call ran, what it returned, what depended on it, and where the result changed.
For agents, that trace should be more than a dashboard a person reviews later. It can become the material the system learns from.
Let experience change the next action.
Neuroscience added a different question: how does a system improve from experience without carrying every prior sensation into every new decision?
We borrow the discipline, not the mystique. Keep the parts of experience that help the next action. Let the rest fall away.
That sequence became rote.
An agent expresses an intent, reaches the world through typed tools, and leaves behind a trace of the path that actually worked. rote can turn that trace into an inspectable Play: the same method, ready for fresh inputs and another permitted agent.
intent→execution→trace→Play→fresh run
Not memory as a larger transcript. Memory as an executable method.
Four people. Four entry points.
The work is collective, but the paths into it are personal.
Hubert Plociniczak
Hubert came through Scala compilers, GraalVM, Erlang, and distributed tracing: semantics before execution; evidence after it.
Say hello on LinkedIn ↗
Roberts Pumpurs
Roberts came through Rust, Solana, high-frequency systems, OpenTelemetry, and trace learning—turning what ran into material for what runs next.
Say hello on LinkedIn ↗
Debasish Ghosh
Debasish has spent a career making domain meaning survive its translation into software, including two books on domain modeling and years with Scala and Rust.
Say hello on LinkedIn ↗We are not finished becoming experts in agents.
No one is. What we do know is how to make the layer beneath them hold: explicit contracts, durable evidence, and methods that can be inspected, shared, and repaired.
If your agents keep solving the same problem twice, we would like to hear the story.