AI agent CI/CD as one governed pipeline.
Agents don't need generic CI/CD bolted on — they need a pipeline that understands what a deploy of an agent means. On a2a, the agent's source lives in a git repo. A push triggers a Gitea Actions build, an automated review gate on the diff, an Argo/Knative reconcile, live smoke tests on a preview URL, and an Ed25519-signed receipt as the deploy's audit artifact. GitOps, a review gate, and provable evidence — one pipeline, purpose-built for agents.
git push · build · review gate · reconcile · smoke · signed receipt
Generic CI/CD wasn't built to deploy agents.
A standard CI/CD pipeline ships a stateless service: build an image, apply it, watch a health check. Bolt that onto an agent and the parts that matter for an agent go missing — nobody reviews the diff for new tool calls or widened grant scopes, nobody verifies the deployed agent actually answers, and the only record of the release is a green checkmark that rotates away. You end up with a pipeline that deploys the agent but can't tell you what it deployed, whether it was reviewed, or whether it works.
Push, and the whole governed pipeline runs.
The agent's source lives in a Gitea repo. A push builds the image with Gitea Actions, gates the diff through an automated agent-reviewer before publish, reconciles the revision onto Knative with Argo, smoke-tests a preview URL, and signs a receipt for the deploy. Build, pod, and Argo logs stream into one deploy timeline — no Grafana required — and scoped grants are injected at deploy, never baked into the image.
Push is the trigger
Every agent gets its own git repo in Gitea. A push is the whole pipeline's entry point — no separate CI config to wire, no external runner to register. The commit is what the build, review, and deploy all reconcile against, and it's the identity the receipt binds to.
Build runs on the push
Gitea Actions builds the image from the pushed source: dependencies resolved, the agent packaged, an image produced and pushed to the registry. Real build logs stream into the deploy timeline as it runs — you watch the build, you don't poll a black box.
The review gate runs before publish
An automated agent-reviewer reads the diff and gates the deploy before anything ships. It runs on the change itself — new tool calls, new grant scopes, risky edits — not after the fact. A failed review stops the rollout; publish is downstream of the gate, not parallel to it.
Argo/Knative reconciles the rollout
Once the gate passes, Argo reconciles the new image onto Knative and the revision rolls out. GitOps in the literal sense — the git commit is the desired state and the platform converges the running agent to it. Argo events land in the same timeline as the build.
Live smoke tests on a preview URL
The new revision comes up on a preview URL and live smoke tests hit it before it takes traffic — a real invocation against the deployed agent, not a unit test against a mock. If the deployed agent doesn't answer correctly, the rollout is caught at the door.
The deploy signs a receipt
Each deploy emits an Ed25519-signed receipt: which commit, which image, whether the review gate passed, whether smoke tests passed. It's the audit artifact for the release — provable evidence a governed pipeline ran, not a green checkmark you have to trust.
Generic CI/CD bolted on vs. an agent-native pipeline.
Frequently asked.
What does CI/CD for an AI agent actually look like on a2a?
Each agent has its own git repo in Gitea. A push triggers a Gitea Actions build that produces and pushes an image; an automated agent-reviewer gates the diff before publish; Argo reconciles the new image onto Knative; live smoke tests hit a preview URL; and the deploy emits an Ed25519-signed receipt recording the commit, image, review result, and smoke result. Build, review, and deploy are one pipeline, not three tools you glued together.
Is this GitOps for agents?
Yes, literally. The git commit in the agent's Gitea repo is the desired state, and Argo/Knative converge the running agent to it. You don't run kubectl apply or a bespoke deploy script — you push, and the platform reconciles the deployed revision to match the commit. The difference from generic GitOps is that the pipeline is agent-native: it knows to review tool calls and grant scopes, and it signs a receipt for the release.
When does the code review gate run — before or after deploy?
Before publish. The automated agent-reviewer reads the diff and gates the rollout while the change is still a candidate, not after it's live. A failed review stops the deploy; the reviewer looks at what actually changed — new tool calls, new grant scopes, risky edits — so the gate is downstream of the build and upstream of the rollout. Publishing is never parallel to review.
How do I know the deployed agent actually works?
Live smoke tests. The new Knative revision comes up on a preview URL, and smoke tests make real invocations against the deployed agent before it takes traffic — not unit tests against mocks. If the deployed agent doesn't answer correctly, the rollout is caught at the door. The build, pod, and Argo logs stream into a single deploy timeline while it happens, so you don't need Grafana to see what the pipeline did.
Where do the agent's credentials come from at deploy?
Scoped grants are injected at deploy, not baked into the image. The image the build produces stays credential-free; the platform injects scoped, audience- and TTL-bound grants when the revision comes up. That keeps secrets out of the registry and out of git, and it means the same image can be promoted without re-baking credentials. What the deploy was granted is recorded in the deploy's signed receipt.
Related guides.
All guides live in the guides index.
Ship agents through a pipeline that proves what it did.
a2a cloud deploys any agent — LangGraph, OpenAI Agents SDK, CrewAI, or custom — from a git push. Gitea Actions builds the image, an automated reviewer gates the diff before publish, Argo/Knative reconcile the rollout, live smoke tests hit a preview URL, and every deploy signs an Ed25519 receipt recording the commit, image, gate, and smoke result. Scoped grants injected at deploy, real build and Argo logs in one timeline, scale-to-zero when idle. GitOps for agents, with proof.