Ask a team how they control a ChatGPT agent's production access and you will usually hear about the credential and maybe the network rules. Ask when that access expires and the room goes quiet. The skipped control is time. The agent's production access almost never ends, and that is the gap.
First, a boundary. hoop.dev does not read or govern what ChatGPT produces. It governs the connection the agent makes to production infrastructure. The query against the production database, the command against the cluster, those are what get scoped and recorded.
The control everyone skips: just-in-time access
Standing production access is the default because it is the path of least resistance. Issue a credential, move on. But a permanent credential means the agent can reach production at any moment, including the moment a prompt goes wrong or the agent is compromised. Just-in-time access closes that window. The agent gets production access for the task and loses it when the task ends.
One model keeps the door open all year. The other opens it for the task and shuts it after. The difference is the entire blast radius.
Why the timer lives at the gateway
An expiry the agent enforces on itself is not enforcement. The access window has to be controlled where the agent cannot extend it. hoop.dev, an open-source Layer 7 gateway, grants and revokes access in the connection path: the agent reaches production through it, and the grant lapses on schedule regardless of what the agent wants.
Why time is the control that gets dropped
Scope and approval feel tangible. You can point at a role and say what it can do; you can point at an approval gate and say who signs off. Time is invisible by comparison. A credential that never expires looks identical, on the day you create it, to one that expires in an hour. The difference only shows up later, when something goes wrong and you discover the agent has held production access for eight months with no task to justify it. That is why the timer is the part teams skip: it costs nothing to omit and its absence is silent right up until it is loud.
Treating production access as time-bound by default flips the cost. Now the unusual case is a grant that persists, and persistence is something someone has to ask for and justify. The quiet default becomes the safe one.
Steps to add just-in-time production access
- Register production connections on hoop.dev with least-privilege credentials.
- Remove any standing grant the agent currently holds.
- Configure just-in-time access scoped to the task window.
- Gate destructive commands with human approval.
- Record every session under the agent's named identity and verify the grant expires.
# access opens for the task and closes after
# 09:14 grant: chatgpt-agent -> prod-db (ttl 30m, task=hotfix-1422)
# 09:31 task complete, grant revoked. No standing prod access remains.
Pitfalls
- Long TTLs that mimic standing access. A 30-day window is not just-in-time. Match the window to the task.
- Re-grant without review. Each production grant should be a deliberate request, not an automatic renewal.
- Forgetting recording. Scoping access without recording leaves you knowing the window but not the actions.
One more, easy to miss: do not let an expired grant fail silently in a way that pushes someone to hand the agent a permanent credential as a workaround. The point of just-in-time access is lost the moment the friction of re-requesting drives a team back to standing access. Make the request path quick, so the secure default stays the convenient one.
FAQ
Does this affect what ChatGPT can generate?
No. hoop.dev governs the production connection the agent uses, not the model. Output is untouched.
What happens when the access window ends?
The grant is revoked at the gateway and the agent can no longer reach production until it requests access for a new task.
Does just-in-time access slow down urgent work?
No. The grant is issued at the start of the task, not negotiated per command, so the agent works at full speed once it has access. What you remove is the idle, between-task standing access, which was pure risk and never made urgent work faster.
Add just-in-time production access with the open-source gateway on GitHub. The hoop.dev learn hub covers JIT patterns, and the getting started guide sets up the first connection.
