Blog

Introducing Agent Signing for Git: Distinct signing identities for your coding agents

Product
·
·
Carey Janecka
Staff Software Engineer
Zeke Mostov
Founding Engineer
Introducing Agent Signing for Git: Distinct signing identities for your coding agents

Agent Signing for Git with Turnkey

Let your coding agents sign Git commits you can distinguish from human-signed commits.

What is the solution? With Agent Signing for Git, Turnkey gives each coding agent its own signing identity without ever placing private keys on the machine where the agent runs. All commit signing takes place inside Turnkey’s secure enclaves. Through the tk CLI, teams keep familiar Git and SSH workflows while controlling which keys each agent can use, tracking signing activity and revoking access independently.

What does it solve? Coding agents usually sign and push with a developer's own GPG or SSH key, which the agent can read and copy. The agent's commits then look like the developer's, and its access cannot be cut without rotating the developer's keys.

How does it solve this? The tk CLI acts as Git's signing program and as an SSH agent, sending each signing request to Turnkey, where the policy engine evaluates it inside a secure enclave before a signature is returned. Each agent gets its own non-root Turnkey user, signing key, committer identity and policies, with every request and approval recorded in Turnkey's activity log.

Who is it built for? Developers, platform engineers and security engineers at companies whose engineers run coding agents such as Claude Code and Codex on laptops, in CI and in remote sandboxes, and who need to know which commits an agent signed and establish a clear audit trail.

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

Agent Signing for Git
“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.”
Bryce FergusonBryce FergusonCEO and co-founder of Turnkey

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.

Agent Signing for Git
QuestionWithout Turnkey: the agent uses your keyWith Turnkey: the agent has its own key
Where the private key livesA file in ~/.ssh or a GnuPG keyring the agent can read and copyTurnkey's secure enclaves; the agent receives signatures
How commits are attributedAs your commitsTo the agent's own committer identity, such as Jane Doe (agent)
What decides whether a signature is issuedAccess to the key filePolicies evaluated inside the enclave, with every request denied by default
How you revoke the agentRotate your own keysDelete 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:

  1. Git calls its signing program: You set that program to tk.
  2. tk sends a sign request: The payload goes to Turnkey, authenticated with the agent's session key.
  3. The policy engine evaluates it: The evaluation happens inside Turnkey's secure enclave.
  4. 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.

Setup prompt

Paste this into your coding agent

Install the Turnkey tk CLI with `curl --proto '=https' --tlsv1.2 -LsSf https://raw.githubusercontent.com/tkhq/tk/main/install.sh | sh`. Install the tk skills with `tk skills install --into <your skills directory>`, read the installed turnkey-tk/SKILL.md, and walk me through bootstrapping my Turnkey organization at https://app.turnkey.com.

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.

Get started with Turnkey today.

Carey Janecka
Staff Software Engineer
Zeke Mostov
Founding Engineer

Related articles

Introducing Sponsored Swaps: Fixed-rate, sponsored stablecoin swaps via integrated providers

Sponsored Swaps lets you offer 1:1 fixed-rate stablecoin swaps and cover swap fees for users. Learn how both controls work with Turnkey Swaps.

Fiat Offramps: Let users withdraw to fiat inside your platform

Let users withdraw crypto to fiat inside your platform. Turnkey's MoonPay Onramp now works in both directions, through the same Turnkey APIs.