
Agent Signing for Git with Turnkey
Let your coding agents sign Git commits you can distinguish from human-signed commits.
Turnkey’s Agent Signing for Git lets coding agents sign Git commits with their own private keys, secured inside Turnkey's secure enclaves.
When coding agents commit code, they typically use the developer's existing signing and SSH keys. This means the agent operates under the developer's identity, making it difficult to distinguish commits written and signed by an agent from those signed by the developer. It also means revoking an agent's access can require rotating the developer's own keys, disrupting access to other repositories and services that rely on them.
We ran into the same problem internally. Our team builds many internal agents and runs our own agent platform, yet our coding agents were still signing commits with our engineers' personal keys. We wanted each coding agent to have its own signing identity, with credentials that could be managed independently of the engineer running it.
Now, with Agent Signing for Git, the same infrastructure Turnkey built to secure private keys for onchain transactions secures Git commit signing. Each agent has its own signing identity, its commits can be attributed directly to it, and its access can be revoked independently of the developer who runs it.
What Agent Signing for Git gives you
“Coding agents are part of every engineering team now, and Turnkey is giving them secure Git signing.The infra we built for securing crypto private keys now supports agent signing for Git. Another step towards securing the guardrails for the agent economy.”
Turnkey lets teams assign each coding agent a separate signing key and a non-root Turnkey user account with permissions scoped through the policy engine.
Each agent has its own key, and its signature proves which key signed the commit. Once the signing key is registered with your Git host and the commit meets its verification requirements, the host can display the signature as verified.
| Question | Without Turnkey: the agent uses your key | With Turnkey: the agent has its own key |
|---|---|---|
| Where the private key lives | A file in ~/.ssh or a GnuPG keyring the agent can read and copy | Turnkey's secure enclaves; the agent receives signatures |
| How commits are attributed | As your commits | To the agent's own committer identity, such as Jane Doe (agent) |
| What decides whether a signature is issued | Access to the key file | Policies evaluated inside the enclave, with every request denied by default |
| How you revoke the agent | Rotate your own keys | Delete the agent's session key, user or policy |
How does Agent Signing for Git work with Turnkey?
The tk CLI acts as Git's GPG or SSH signing program, so git commit -S and git verify-commit work unchanged. Git commits go through the same process Turnkey uses to sign blockchain transactions.
Each signed commit or tag follows the same flow:
- Git calls its signing program: You set that program to tk.
- tk sends a sign request: The payload goes to Turnkey, authenticated with the agent's session key.
- The policy engine evaluates it: The evaluation happens inside Turnkey's secure enclave.
- Turnkey returns the signature: If a policy allows the request, tk hands the signature to Git in the format Git expects.
Agent Signing for Git
How Agent Signing for Git signs a commit
The private key stays in Turnkey's secure enclaves, and the agent receives only the signature.
Sign a commit
Git
git commit -S calls its signing program
The signing program is set to tk
Request a signature
tk
Sends the payload to Turnkey as a sign request
Uses the agent's Turnkey session key
Verify
Signed commit
tk hands the signature to Git in the format Git expects
git verify-commit works unchanged
Turnkey
Authentication and policy engine
Checks the session key, then signs in a secure enclave only if a policy allows it
The Git signing key is either a GPG key (an OpenPGP key, backed by an account in a Turnkey wallet) or an SSH key (a Turnkey Ed25519 private key).
The tk CLI also works for SSH. Agents push and clone over SSH as they do today, and the key stays in Turnkey instead of on the agent's machine.
Agent Signing for Git also works when no developer is at the keyboard. In automated build pipelines (CI), the job carries the agent's Turnkey credential, and Git signs each commit through tk the same way.
For an agent running unattended in a remote container or VM, a separate signing service holds the credential, so the agent can ask for signatures without ever holding a private key or credential itself. The account that registers and renews that service's short-lived keys can neither sign nor see the private key.
Telling an agent's commits apart from a developer’s
Each agent connects as its own non-root Turnkey user. We recommend a committer identity that uses your name with "(agent)" and your email plus-tagged with the agent's user name, such as Jane Doe (agent) <[email protected]>.
With that format, the agent's commits group with yours in git shortlog, and your Git host sends the email confirmation to your inbox. Your Git host can show both GPG and SSH signatures as verified once you add the public key and a verified committer email to your account. For a GPG key, the committer email must also appear in the key's user ID.
Several agents on one machine, such as Claude Code and Codex, each get their own user, tk profile, keys and policies. You can tell them apart in the activity log and revoke one without affecting the others.
Each coding agent then has a distinct agent identity in your Git history. Turnkey's activity log records every signing request and approval, attributed to the agent and its session.
Policy-controlled signing: Which keys an agent can use
Turnkey denies every request by default, and only policies let a user sign with a key. Turnkey policies control which users can sign with which keys, so each agent can sign only with the keys a policy names.
It is the same policy engine Turnkey runs for wallets, evaluated inside secure enclaves, which gives teams granular control over how each signing key is used.
An agent's instructions can tell it which repositories to touch, but a prompt is not a guardrail. Putting governance at the signing layer means the policy is evaluated inside the enclave on every sign request, whatever the agent believes it was asked to do.
Isolated, unreadable private keys in Turnkey's secure enclaves
Key generation, signing and the policy engine all run in secure enclaves. These enclaves operate in hardware-enforced isolation, with no persistent storage, no interactive access and no external networking.
The tk CLI sends commit-signing payloads to Turnkey and receives signatures in return, without bringing the private key into the agent's environment. Keys are never exposed to the agent or to Turnkey operators.
Revoking a coding agent's signing access without rotating your keys
Revocation stops future signing. GitHub keeps a verified commit signature verified within its repository's network, so commits the agent already pushed keep their badge.
The agent signs with its own Turnkey user and key, so revoking it leaves your own keys untouched. You can choose how much to remove:
- End the current session: For an agent on session keys, delete its current session key to stop all its signing and SSH. If a provisioner renews the agent's sessions, the next renewal restores access.
- Remove the agent: Delete the agent's user. This is the off switch a renewal cannot undo.
- Stop one wallet or SSH key: Delete the policy for it.
With each agent's signing identity and permissions managed independently, teams can give coding agents the access they need without sharing developer credentials and revoke that access when it is no longer needed.
Getting started with Agent Signing for Git
The fastest way to set up is to paste one prompt into your coding agent, taken from the Agent Signing for Git docs.
Paste this into your coding agent
Install the Turnkey tk CLI with `curl --proto '=https' --tlsv1.2 -LsSf https:/
After that, tell your agent what you want to set up, such as local Git signing, and it picks the matching skills to follow. Like Turnkey AI Skills, the tk skills are instructions your agent follows step by step.
Developers can sign their own commits the same way, with no signing key file to lose. If you keep signing with your own key on the same machine, put the agent's Git config in the agent runtime's environment rather than in ~/.gitconfig, so your own signing setup stays as it is.
Agent Signing for Git joins Managed Secrets in bringing Turnkey's private key management and policy engine to the credentials AI agents use. Keys stay isolated, policies stay enforceable and every agent signature stays attributable.



