Begin with the requirement, because it settles the whole design. For session recording of an autonomous agent like Devin to be worth anything, the record has to live outside the process Devin controls. An agent that records itself can omit, retry, or overwrite, and the one session you most need to review is the one most likely to be missing. The record must sit where the agent cannot reach it.
That requirement points to a single place: the connection the agent's commands travel through. Get the recording boundary right and the rest is configuration.
The architectural requirement behind session recording
State it plainly. The recording boundary must be outside the agent. If Devin can write the log, Devin can be steered into not writing the part that matters, and a crash can take the rest. So the recording cannot be a feature of the agent; it has to be a property of the path between the agent and the infrastructure it touches.
Capture the command where it crosses that path, attribute it to an identity, and store it beyond the agent's reach. Those three properties, external capture, attribution, and durability, are what make a recording admissible in an incident review instead of merely suggestive.
How hoop.dev meets it
hoop.dev is an open-source Layer 7 access gateway. An agent runs near the resource and dials out to the gateway; Devin reaches the database or service through that gateway. The recording happens at the gateway, which is exactly the outside-the-agent boundary the requirement demands:
- Recording is command level, capturing the actual queries and commands on the wire, not Devin's summary of them.
- It runs at the gateway, outside Devin, so the agent cannot edit or skip it.
- Each session is attributed to the identity that authenticated, so the record answers who as well as what.
hoop.dev records the infrastructure actions Devin takes. It does not record the model prompt or output, because the action that matters for review is the command that hit the system, not the reasoning that produced it. The gateway model is described on the hoop.dev site.
Enabling it
- Run the hoop.dev agent next to the resource and register the connection.
- Confirm recording is enabled on that connection.
- Give Devin its own identity so sessions are attributable.
- Route Devin through the connection, run a command, and read the session back.
Pitfalls to avoid
Do not accept the agent's own transcript as the system of record; it lives inside the process you cannot trust. Do not run multiple agents under one identity, or the recording cannot tell them apart. And do not let any connection bypass the gateway, because an unrecorded path is a blind spot by definition, and blind spots are where incidents hide.
It is worth being precise about what the recording is for, because that shapes what you capture. The point is not to surveil the agent's intent or to second-guess its reasoning. The point is to have an authoritative answer to a narrow, important question after the fact: what commands actually ran against this system, under which identity, and in what order. A recording scoped to that question is small, durable, and easy to reason about. A recording that tries to capture the agent's whole thought process is large, noisy, and still does not answer the question that matters during an incident.
This is also why the recording outlives the agent. Devin may be restarted, reconfigured, or replaced by a different agent next quarter. The sessions it ran are still on record at the gateway, attributed and intact, because they were never the agent's to keep. The system of record belongs to the boundary, not to whatever happened to be connecting through it that week.
FAQ
Why not use Devin's built-in logs?
They live in the agent's process. The requirement is a record outside the agent, which only the gateway provides.
Does recording capture the model's reasoning?
No. It captures the commands Devin runs over the connection, not the prompt or completion.
Is hoop.dev open source?
Yes, it is MIT licensed.
Record agent sessions outside the agent, where they hold up. Clone the hoop.dev GitHub repository and enable recording on your first connection with the getting started guide.
