November 15, 2026
Posted by Avi Sharon
Summary:
Secretless access and runtime authorization are important concepts in AI agent security, but what do they look like in practice? At Akeyless, we use our own technology to secure AI agents performing everyday work across our internal systems. In this post, we share a real-world example: a documentation agent that reviews code changes, validates them against development tickets, and prepares documentation updates for human review. We’ll show how Akeyless SecretlessAI® keeps credentials out of the agent’s hands while Agentic Runtime Authority controls what the agent is allowed to do.
At Akeyless, we don’t just help customers secure AI agents. We use agents in our own day-to-day work, and we rely on the same Akeyless security capabilities to protect our systems and data. Here’s one example of how we’re putting our own technology to work.
The Agent Does the Work Without Holding the Keys
AI agents are moving from chat windows into real workflows. They read tickets, review code and open pull requests, often with no human watching. To do that, they need access to real systems, and access usually means credentials.
An agent that holds a password or API key can leak it, misuse it, or be tricked into handing it over by a cleverly worded instruction. Telling the model to “behave” is not a security control.
This post walks through a real workflow we run every week at Akeyless. An AI agent checks a developer’s pull request against its ticket, then writes the matching documentation. It does this with zero static, long-lived credentials, it never sees a single secret, and every action it takes is checked live before it happens.
The Use Case: A Documentation Agent That Runs on Its Own
When a developer opens a pull request for a new feature, the agent picks it up and does three things:
- Validates the change. It compares what the developer built against what the ticket asked for.
- Writes the docs. It drafts or updates the documentation pages that cover the change.
- Opens a pull request in the documentation repository, so a human can review and approve it.
To do this, the agent needs access to four systems: an AI model provider, the product code, the ticketing system and the documentation repository. Each connection requires credentials and would normally mean another secret stored somewhere. In this workflow, the agent stores no secrets and never sees a credential.
Principle 1: Start With a Verified Identity, Not a Stored Secret
The workflow doesn’t need a stored password, API key, or access token to authenticate to Akeyless. That eliminates the need to keep a long-lived credential in the repository’s settings. That means there is nothing to leak and nothing to rotate.
Instead, when the job starts, GitHub issues it a short-lived identity token that is valid for that one run only. Akeyless checks that the token really came from GitHub, and from this specific repository, before it hands back an equally short-lived session.
Tokens that fail validation or come from another repository are rejected. The GitHub token and Akeyless session expire automatically. The starting point of the entire flow is an identity, not a secret.
Principle 2: The Agent Never Sees a Credential
With Akeyless SecretlessAI®, the agent can use access without ever holding it. The agent sends its request through the Akeyless Gateway, which checks the requested action against security policy. If approved, the Gateway uses the necessary credential to execute the request against the target system on the agent’s behalf and returns the result. The agent never receives the credential or connects directly to the target system.
- The AI model key is fetched just in time, only for the moment the model is called. It is never shared with the rest of the job.
- Code repository access comes from a dynamic secret: a fresh, short-lived credential created for this run and destroyed after it. The agent can ask to read the pull request under review, but it never sees the credential that makes that possible.
- Ticketing access uses a static secret, a service account for the ticketing system. That account stays locked inside Akeyless. The agent never receives the login or the token.
- Documentation repository access is another dynamic secret. Akeyless uses this credential to execute the agent’s requests to create a working branch, add documentation files, and open a pull request for review. The credential itself is never exposed to the agent.
The result: even if an attacker fully took over the agent’s environment and searched every file, they would not find a credential to steal.
Principle 3: Runtime Authority Enforces Policy on Every Action, Live
Hiding credentials is half the story. The other half is controlling what an agent operating under a verified identity can do with the access it borrows. Akeyless Agentic Runtime Authority enforces the boundaries on that access.
Runtime Authority sits on every secret in this flow. Each request the agent makes is checked against a policy attached to that secret, at the moment of action, before anything happens. The check is independent of the model and the prompt, and of any instruction hidden in a ticket.
The distinction between permissions and intent is important here. The service account behind the ticketing system may be able to read every ticket in the company. The repository credential may be able to read every line of code. Runtime Authority narrows that down to exactly what this task needs. If the agent tries to go further, the request is blocked, even though the underlying account would technically allow it.
Example policies
| Secret | Allowed | Blocked |
|---|---|---|
| Product code repository (dynamic) | Read the changes in the pull request under review | Copying code from the main repository into docs or output; reading unrelated files or other repositories; approving, commenting on or merging the developer’s pull request |
| Ticketing system (static) | Read the one ticket linked to the pull request | Searching, listing or exporting tickets; reading other projects; editing, commenting on or closing tickets; opening attachments |
| Documentation repository (dynamic) | Create a working branch, add documentation files, open a pull request for review | Merging its own pull request; pushing to the main branch; deleting branches; rewriting history; changing repository settings; editing its own workflow or rules |
| AI model key | Calls to the approved model for this task | Exposing or exporting the key; use outside this run |
The agent might still attempt an action on the blocked list, especially if a manipulated prompt directs it to. But the request goes through Runtime Authority, and Runtime Authority says no. It’s the difference between asking an assistant not to open a door and never giving them the key.
Every request, allowed or blocked, is recorded and tied to the agent and the run that made it. Security teams get an independent audit trail of what the agent actually tried to do, not just what it reports.
The Full Flow, Step by Step

The flow starts from a verified identity, not a secret. From step 3 onward, every request the agent makes passes through Runtime Authority before it reaches a real system.
How this Unleashes Safe Agentic Automation
None of this depends on the model being well-behaved or the ticket being written in good faith. It depends on three guarantees underneath the agent:
- No static secrets. The flow starts from a verified identity, and every credential expires on its own.
- No credential exposure. The agent uses access it never holds, so there is nothing to leak.
- Live, intent-aware control. Every action is checked against policy at the moment it happens, so the agent can’t do anything harmful, even with broad permissions underneath.
That is what makes it reasonable to let an AI agent work on real systems unattended. Not because it is trustworthy, but because the cost of it being wrong, confused or manipulated is capped before it ever reaches production.
Want to see how this could work for your own AI agents? Book a demo and we’ll show you how Akeyless gives your AI agents access without giving them the keys.
Frequently Asked Questions
How can AI agents access enterprise systems without exposing credentials?
AI agents can use identity-based authentication and brokered access to interact with enterprise systems without receiving the credentials used to connect. In our documentation workflow, for example, Akeyless SecretlessAI® keeps downstream credentials out of the agent’s reach while allowing it to retrieve information and submit documentation changes.
How can an AI agent authenticate without stored secrets?
One approach is to use a trusted workload identity rather than embedding a reusable credential in the workflow. In our example, GitHub issues a short-lived identity token when the documentation job starts. Akeyless validates the token and verifies that it came from the authorized repository before granting a short-lived session. This eliminates the need to store a password or API key in the workflow to authenticate to Akeyless.
How can organizations prevent AI agents from performing unauthorized actions?
Authentication and access permissions alone don’t determine whether an individual action is appropriate. Akeyless Agentic Runtime Authority evaluates requests against security policies before allowing them to reach connected systems. In our workflow, the agent can read the ticket associated with a pull request and propose documentation updates, but policies prevent it from accessing unrelated tickets or merging its own changes.
How can security teams audit AI agent activity?
Akeyless records allowed and blocked requests and associates them with the agent and the workflow run. This gives security teams an independent record of what the agent attempted, rather than relying solely on its own account of its actions. The audit trail supports investigation, accountability, and verification that the agent operated within its assigned permissions.