"Which is faster, Argo CD or Flux?" sounds like a question with a number for an answer. I wanted that number, so I built a small lab that runs both tools side by side on one kind cluster and times them in CI. The answer turned out to be four different numbers that point in opposite directions, plus one result I still can't fully explain.
Short version for people in a hurry. On this setup, Argo CD put a deleted Deployment back in about 3 seconds and Flux took about 70. A new Git commit went live in about 8 seconds with Flux and about 19 with Argo CD. Both results come from the same cluster with the same 10 second interval. Neither tool is "faster". They watch different things.
The rest of this post is about why, and what that means for how you tune either one.
The lab
Everything lives in gitops-duel-argocd-vs-flux, and all numbers below are from tag v1.0.1. Terraform installs Argo CD (Helm chart 9.0.0, Argo CD v3) and Flux 2 (chart 2.14.0) into a single-node kind cluster created by helm/kind-action@v1.15.1. For the benchmark each tool manages its own copy of the same tiny app, one nginx Deployment with one replica and a Service. The two copies differ only in a label that says which tool applied it.
The Argo CD side is a plain Application with automated sync, prune and self-heal.
apiVersion: argoproj.io/v1alpha1 kind: Application metadata: name: nginx-app namespace: argocd spec: project: default source: repoURL: https://github.com/justrunme/gitops-duel-argocd-vs-flux.git targetRevision: main path: apps/argocd/nginx destination: server: https://kubernetes.default.svc namespace: argocd-demo syncPolicy: automated: prune: true selfHeal: true syncOptions: - CreateNamespace=true - PrunePropagationPolicy=foreground The Flux side is a GitRepository plus a Kustomization with wait: true, so Flux only reports Ready once the workload is healthy.
apiVersion: source.toolkit.fluxcd.io/v1 kind: GitRepository metadata: name: local-repo namespace: flux-system spec: interval: 10s timeout: 60s url: https://github.com/justrunme/gitops-duel-argocd-vs-flux.git ref: branch: main --- apiVersion: kustomize.toolkit.fluxcd.io/v1 kind: Kustomization metadata: name: flux-nginx-app namespace: flux-system spec: interval: 10s timeout: 60s retryInterval: 10s path: ./apps/flux/nginx prune: true wait: true targetNamespace: flux-demo sourceRef: kind: GitRepository name: local-repo Keep timeout: 60s and retryInterval: 10s in mind. They come back later.
What gets timed
The benchmark script (.github/scripts/benchmark-gitops.sh) measures four things, always in the same order, and polls the cluster every 0.5 s with kubectl.
- Cold start. Delete the Application or Kustomization and the workload, recreate the GitOps object, stop the clock when the Deployment is available and the tool says it's done (Synced + Healthy for Argo CD,
Ready=Truefor Flux). - Self-heal.
kubectl scale --replicas=0behind the tool's back, start the clock once the drift is visible, stop when the original replica count is back and ready. - Deletion recovery.
kubectl delete deployment, stop when it exists again and is available. The repo used to call this "rollback". It isn't one, nothing is reverted in Git, and v1.0.1 renamed it. - Commit to ready. Push an image tag change (
nginx:1.27-alpinetonginx:1.26-alpineor back) to a temporaryci/bench-<run-id>branch, start the clock after the push is visible on the remote, stop when the Deployment runs the new image. No webhooks, both tools have to discover the commit by polling.
The core of the self-heal check is boring on purpose (trimmed a little here).
kubectl scale deployment "${APP_NAME}" --replicas=0 -n "${NAMESPACE}" # ...wait until .spec.replicas reads 0, then: start_time=$(now) while [ "$(elapsed_int "${start_time}")" -lt "${TIMEOUT}" ]; do current=$(kubectl get deployment "${APP_NAME}" -n "${NAMESPACE}" -o jsonpath='{.spec.replicas}') ready=$(kubectl get deployment "${APP_NAME}" -n "${NAMESPACE}" -o jsonpath='{.status.readyReplicas}') if [ "${current}" = "${original}" ] && [ "${ready}" = "${original}" ]; then elapsed_since "${start_time}"; break fi sleep "${POLL_INTERVAL}" done Each metric was sampled three times per tool and per profile, and the tables report the median with min and max. The script exits non-zero if any measurement fails, so a missing number would break the job instead of turning into a blank cell.
There are two profiles.
| Profile | Argo CD timeout.reconciliation | Flux interval (GitRepository and Kustomization) |
|---|---|---|
equal-10s | 10s | 10s |
defaults | 180s | 1m |
equal-10s is the fair fight. defaults is closer to what you get out of the box, with one compromise. Flux's Kustomization interval is a required field with no built-in default, and the repo treats 10 minutes as the usual value, but 10 minutes per sample would make CI crawl. So the profile uses 1 minute as a stand-in.
The numbers
All values come from docs/results.md at v1.0.1, produced by the Demo results workflow (run 38131680035, 2026-10-11). Seconds, median of 3, on this setup.
Profile equal-10s
| Cold start | Self-heal | Deletion recovery | Commit to ready | |
|---|---|---|---|---|
| Argo CD | 3.759 | 3.666 | 3.130 | 19.068 (15.300 to 36.912) |
| Flux | 6.167 | 12.767 | 70.208 (69.905 to 70.444) | 8.289 (4.006 to 8.843) |
Profile defaults
| Cold start | Self-heal | Deletion recovery | Commit to ready | |
|---|---|---|---|---|
| Argo CD | 3.768 | 3.623 | 3.170 | 312.054 (206.794 to 344.024) |
| Flux | 6.130 | 65.157 | 119.997 | 54.182 |
Argo CD wins three columns and Flux wins one. If you stopped there you'd call Argo CD the faster tool. The more useful question is which numbers move when you change the interval, and which don't.
Argo CD's self-heal and deletion recovery barely move between profiles (3.666 vs 3.623, 3.130 vs 3.170) even though its reconciliation timeout went from 10 to 180 seconds. Flux's self-heal goes from about 13 to about 65 seconds when its interval goes from 10 seconds to a minute. Commit to ready moves for both tools. That pattern tells you how each one notices change.
Two different watchers
Argo CD watches the cluster and polls Git. The application controller keeps a cache of live resources fed by Kubernetes watch APIs (HA docs). When someone scales the Deployment to zero, the controller hears about it through the watch, sees the app as OutOfSync, and with selfHeal: true it syncs right away. That path never waits for timeout.reconciliation, which is why the self-heal and deletion numbers stay at 3 to 4 seconds in both profiles.
Git is a different story. Argo CD finds new commits by polling, and the FAQ describes the stock behaviour as 120 seconds plus up to 60 seconds of jitter, set through two keys in argocd-cm.
apiVersion: v1 kind: ConfigMap metadata: name: argocd-cm namespace: argocd data: timeout.reconciliation: 120s timeout.reconciliation.jitter: 60s The repo sets only timeout.reconciliation and never touches the jitter key. That fits the spread in the 10 second profile, where commit to ready ranged from 15.3 to 36.9 seconds instead of sitting near 10.
Flux polls Git and reacts to new revisions, and it re-applies only on its schedule. source-controller polls the GitRepository at its interval. When it publishes a new artifact revision, kustomize-controller picks that up immediately. The Kustomization spec says a source revision change "is handled instantly outside the interval window". So a commit costs one Git poll plus an apply, which matches about 8 seconds at a 10 second interval and about 54 seconds at 1 minute.
Drift is handled differently. Nothing tells kustomize-controller that someone ran kubectl scale. It finds out on its next scheduled reconcile, when it applies the manifests again and corrects whatever changed. Self-heal is therefore bounded by the Kustomization interval, and the numbers sit just above it (12.8 s at 10 s, 65.2 s at 1 m). They sit close to a full interval rather than half of one, which makes sense given the measurement order. Self-heal runs right after the cold start, so the last successful reconcile has only just finished and the next one is almost a whole interval away.
The 70 second outlier
Flux's deletion recovery is the number I'd flag in any review. 70.208 seconds at a 10 second interval, with a spread of only half a second across three samples. Then 119.997 seconds in the slower profile. If Flux only had to wait for its next reconcile, I'd expect something close to the self-heal number.
Look at the arithmetic, though. The Kustomization has timeout: 60s, and retryInterval equals the interval. 60 + 10 = 70, and 60 + 60 = 120. Both profiles land on that sum with very little noise.
My reading, which I have not confirmed from controller logs, goes like this. Deletion recovery starts the instant self-heal ends, and self-heal ends when the script sees the replica ready. With wait: true, kustomize-controller may still be inside the health check for that same reconcile. Deleting the Deployment mid-wait means the health check can't pass until the 60 second timeout fires, the reconcile is marked failed, and the next attempt comes after retryInterval. That attempt recreates the Deployment. If that's right, the 70 seconds says more about how the benchmark chains its steps than about how Flux handles a deleted object on a quiet cluster. Out-of-band deletes don't wait politely for health checks in real life either, so it's not a pure artifact.
The way to check would be to rerun deletion recovery with a pause before the delete, or with timeout: 30s, and see whether the number tracks the timeout. Until then, read 70 seconds as "this setup, this order of steps", which is also how the repo's EVIDENCE.md words it.
The Argo CD number I can't explain yet
In the defaults profile Argo CD took 312 seconds median for commit to ready, with samples of 206.8, 312.1 and 344.0. The profile sets timeout.reconciliation: 180s. With up to 60 seconds of default jitter on top, I'd expect detection within roughly 240 seconds, plus a few seconds of sync. Two of the three samples are well past that.
I don't have a confirmed cause. The timer starts only after the push is visible on GitHub, so a slow push doesn't explain it. Caching between the application controller and the repo server is where I'd look first. Three samples is also very few for a metric with this much spread. I'm leaving it as an open question rather than guessing.
What I'd take from this
On this setup, a few things hold up.
Drift correction speed comes from how each tool watches, much more than from tuning. Argo CD's watch-based self-heal fixed drift in about 3.6 seconds no matter how slowly it polled Git. Flux's drift window is the Kustomization interval. Flux's own docs say the interval "should be" at least 60 seconds, and the lab's 10 seconds is far below that. So if somebody running kubectl edit in production and getting reverted within seconds matters to you, that's a point for Argo CD. If you'd rather have a predictable window where a hotfix survives until the next scheduled run, that's a point for Flux (or for Argo CD with selfHeal turned off for that app).
Commit latency on this setup is mostly polling time. Neither tool used webhooks in this lab, on purpose, and both were limited by how often they asked Git. In a real setup I'd add webhooks for both before touching intervals. For Flux that's a Receiver in notification-controller pointing at the GitRepository.
apiVersion: notification.toolkit.fluxcd.io/v1 kind: Receiver metadata: name: github-receiver namespace: flux-system spec: type: github events: - push secretRef: name: webhook-token resources: - apiVersion: source.toolkit.fluxcd.io/v1 kind: GitRepository name: local-repo For Argo CD, a GitHub webhook that posts to the API server's /api/webhook endpoint, with the shared secret stored as webhook.github.secret in argocd-secret. With either in place you can relax the poll interval (Argo's FAQ suggests 15 minutes or an hour as examples once webhooks work) and keep polling only as a safety net. I haven't benchmarked the webhook path in this repo, so I have no numbers for it.
Flux's knobs are really separate dials. GitRepository interval controls how fast you see new commits. Kustomization interval controls how fast drift gets corrected and how much load the re-apply puts on the API server. timeout and retryInterval control how long a stuck reconcile blocks the next one, which, if my reading of the 70 seconds is right, matters more than people expect. In the lab both intervals and retryInterval got the same small value for a fair comparison. In practice they usually shouldn't be.
What these numbers are not
The repo's EVIDENCE.md says it plainly, and I agree with it. These are single-node kind timings for a one-replica nginx app with N=3. They are not production sync SLOs and say nothing about clusters with thousands of Applications or Kustomizations. Cold start for Flux also reuses an already-fetched GitRepository artifact, while Argo CD's cold start creates a brand-new Application, so even the 3.8 vs 6.2 second comparison isn't strictly apples to apples. I don't have a breakdown of where Flux's extra 2.4 seconds goes.
What the lab does show is the shape. Argo CD reacts to the cluster and waits for Git. Flux reacts to Git and waits for its own schedule to look at the cluster. Pick based on which of those you want to be fast, then tune the intervals with that in mind.
If you want to rerun it, the repo's README covers terraform apply on a local kind cluster, and the Demo results workflow can be triggered manually. I'd be curious whether someone gets a different deletion recovery number with a pause before the delete.


