What is the default forks setting?

Ansible defaults to 5 forks, meaning it processes 5 hosts in parallel. This is conservative for most use cases. Increase to 20–50 for large fleets. Set it in ansible.cfg or with the -f flag. Higher values use more local CPU and memory.

Why is SSH overhead significant?

By default, Ansible creates a new SSH connection for each task on each host. With 20 tasks and 50 hosts, that's 1,000 SSH connections. Each connection has handshake overhead (0.5–2 seconds). Enable pipelining to reuse connections across tasks.

What is the 'free' strategy?

The default 'linear' strategy waits for all hosts to complete a task before moving to the next. The 'free' strategy lets each host proceed independently, so fast hosts don't wait for slow ones. This can reduce total time by 20–40% for heterogeneous fleets.

How does mitogen improve performance?

Mitogen replaces Ansible's default SSH+shell execution with a persistent Python connection. This eliminates per-task SSH overhead and reduces data transfer. Typical speedups are 2–7x. It's a drop-in replacement with minimal configuration.

How can I estimate task time for planning?

Run the playbook on a small subset (5–10 hosts) with verbose timing: ANSIBLE_CALLBACK_WHITELIST=profile_tasks. This profiles each task. Average the results for your per-task estimate. Cache-hit tasks (already configured) are much faster.

When should I split a playbook?

Split when: (1) total runtime exceeds your maintenance window, (2) different host groups need different tasks, (3) some tasks are idempotent and can run independently, (4) you want to parallelize across CI/CD jobs. Monitoring trends in this area over successive periods will highlight improvement opportunities and confirm whether changes are producing the desired effect.

Ansible Playbook Time Estimator

Estimate Ansible playbook execution time based on number of hosts, tasks, SSH connection overhead, and parallelism.

Target Hosts

Tasks in Playbook

Avg Time per Task

sec

SSH Overhead per Task

sec

Forks (Parallelism)

Execution Strategy

SSH Pipelining

Gather Facts

Total Estimated Time

9.0 min

5 batches × 1.8 min/batch

Host Batches

5.00

10 hosts per batch (forks=10)

Time per Host

1.8 min

20 tasks @ 3s avg + SSH overhead

SSH Connections

105.00

20 conn/host/batch

SSH Time Share

38.9%

56.1% actual task work

Fact Gathering

+3s/host

Consider caching with fact_caching

With Mitogen

2.3 min

~4× faster (6.8 min saved)

Strategy Bonus

None

Linear: all hosts wait per task

Time Composition

Task Execution58.3%

SSH Overhead38.9%

Fact Gathering2.8%

Fork Scaling Analysis

Forks	Batches	Est. Time	Minutes	vs Current
1	50	1h 30m	90	+1h 21m
5	10	18.0 min	18	+9.0 min
10 ←	5	9.0 min	9	current
20	3	5.4 min	5.4	−3.6 min
50	1	1.8 min	1.8	−7.2 min
100	1	1.8 min	1.8	−7.2 min

Optimization Recommendations

Optimization	Est. Savings	Effort
Enable SSH pipelining	~70% SSH overhead	Low
Switch to free strategy	~20–25% total	Low
Disable/cache fact gathering	~3s/host	Low
Use Mitogen	~75% total time	Medium
Increase forks to 20+	Fewer batches	Low
Async tasks where possible	Variable	Medium

Planning notes, formulas, and examples

About the Ansible Playbook Time Estimator

Ansible playbook execution time depends on several factors: the number of target hosts, the number of tasks, SSH connection overhead per host, task execution time, and the forks (parallelism) setting. For large fleets of hundreds or thousands of hosts, playbook execution can take minutes to hours.

This calculator estimates playbook runtime based on your infrastructure parameters. It considers Ansible's execution model: tasks execute sequentially within each play, while hosts are processed in parallel batches determined by the forks setting.

Understanding execution time helps plan maintenance windows, set CI/CD timeouts, and determine when to optimize with strategies like free strategy, pipelining, or mitogen acceleration.

When This Page Helps

Long playbook runs block maintenance windows and CI/CD pipelines. This estimator helps predict execution time and identify when to increase forks, enable pipelining, or split playbooks.

How to Use the Inputs

Enter the number of target hosts.
Enter the number of tasks in the playbook.
Enter the average time per task in seconds.
Enter the SSH connection overhead per host.
Enter the Ansible forks setting (default is 5).
Review the estimated total execution time.

Formula used

Batches = ceil(hosts / forks)
Per-batch time = (tasks × avg_task_time) + ssh_overhead
Total Time = batches × per_batch_time

Example Calculation

Result: ~310 seconds (5.2 minutes)

Batches: ceil(50 / 10) = 5 batches. Per-batch: (20 × 3s) + 2s = 62 seconds. Total: 5 × 62 = 310 seconds (5.2 minutes).

Tips & Best Practices

Increase forks (default 5) to 20–50 for faster execution on many hosts.
Enable SSH pipelining to reduce connection overhead per task.
Use the 'free' strategy to allow fast hosts to proceed without waiting for slow ones.
Use mitogen to dramatically reduce per-task overhead (2–7x speedup).
Cache facts with fact_caching to avoid gathering facts on every run.
Split large playbooks into smaller plays that can run independently.

Ansible Execution Model

Ansible processes hosts in batches (determined by forks). Within each batch, tasks run sequentially per play. The total time is batch_count × per_task_time × task_count plus connection overhead. Understanding this model is key to optimization.

Optimization Hierarchy

From highest to lowest impact: (1) Enable pipelining to reduce SSH connections, (2) Increase forks to process more hosts in parallel, (3) Use mitogen for 2–7x speedup, (4) Enable fact caching, (5) Use free strategy for heterogeneous fleets, (6) Optimize individual tasks.

Scaling Ansible for Large Fleets

For 1,000+ hosts, consider Ansible Tower/AWX for job distribution, or use pull-based tools (ansible-pull) for self-service configuration. At this scale, execution time becomes a primary constraint and creative batching strategies are essential.

Sources & Methodology

Last updated: February 8, 2026

Frequently Asked Questions

Ansible defaults to 5 forks, meaning it processes 5 hosts in parallel. This is conservative for most use cases. Increase to 20–50 for large fleets. Set it in ansible.cfg or with the -f flag. Higher values use more local CPU and memory.