COMMAND ORCHESTRATION PLATFORM

Build. Batch. Execute.
At any scale.

Argonaut reads from standard input, intelligently batches arguments, and executes commands in parallel — turning any pipeline into a high-throughput orchestration engine.

Start Orchestrating See It Work

orchestrate.sh

$ find ./services -name '*.deploy' -print0 | argonaut -0 -P 8 -I {} deploy --target {}

[slot:0] deploying → auth-service [slot:1] deploying → api-gateway [slot:2] deploying → billing-engine [slot:3] deploying → user-service ✓ 4 services deployed in parallel (8 slots available)

PIPES INTO EVERYTHING

find

grep

ls

cat

curl

docker

kubectl

aws

git

sed

awk

rm

FEATURES

A complete orchestration runtime.

Every flag is a primitive in our execution engine. Compose them to build exactly the pipeline throughput profile your workload demands.

⚡

Parallel Execution Engine

Run up to N processes simultaneously with -P max-procs. Set to 0 for maximum parallelism. Dynamically scale with SIGUSR1/SIGUSR2 signals at runtime.

📦

Intelligent Argument Batching

Control batch size precisely with -n max-args. Argonaut groups arguments to minimize exec calls while respecting system-defined command line limits.

🔄

Template Substitution

Define a replace string with -I {} and Argonaut injects each input item into your command template. Perfect for complex orchestration patterns.

🛡️

Null-Safe Input

Handle filenames with spaces, quotes, and special characters cleanly using -0 null-terminated input. Pairs natively with find -print0.

📏

Line-Based Processing

Process input line by line with -L max-lines. Each batch gets exactly the number of input lines you specify — no more, no less.

🧪

Interactive Mode

Review every command before execution with -p interactive prompting. Combined with -t verbose tracing for complete auditability.

🚫

Empty Input Guard

Prevent unnecessary executions with -r. When stdin is empty, Argonaut skips the command entirely — zero wasted cycles, zero side effects.

🔧

Process Slot Variables

Assign unique slot IDs to each parallel worker via --process-slot-var. Build load distribution, temp file isolation, and worker-aware logging.

HOW IT WORKS

From stdin to orchestrated execution.

Ingest

Argonaut reads items from standard input, delimited by whitespace, newlines, or null characters. Pipe output from any command — find, grep, ls, anything.

find /data -name "*.csv" -print0 |

Batch

Arguments are intelligently grouped based on your configuration — by count (-n), by lines (-L), or by max command-line length (-s).

argonaut -0 -n 50 -P 4

Execute

Each batch is dispatched to the target command. With -P, multiple batches run in parallel across process slots. Argonaut manages the full lifecycle.

process --input

Complete

Argonaut waits for all child processes to terminate, collects exit statuses, and reports. Any invocation exiting 255 triggers an immediate halt — fail-fast by default.

✓ 2,400 items processed across 48 batches

0B+

Commands Orchestrated

Avg Throughput Improvement

Execution Reliability

Enterprise Deployments

COMPARISON

Why teams switch to Argonaut.

Capability	Manual Loops	GNU Parallel	Argonaut
Parallel execution	❌ Sequential	✅ Yes	✅ `-P N`
Null-safe input	❌ Breaks on spaces	✅ `-0`	✅ `-0`
Argument batching	❌ One at a time	✅ `-n`	✅ `-n` / `-L` / `-s`
Template substitution	⚠️ Manual variable	✅ `{}`	✅ `-I {}`
Runtime scaling	❌	❌	✅ SIGUSR1/2
Process slot isolation	❌	⚠️ Custom	✅ `--process-slot-var`
Zero dependencies	✅	❌ Perl required	✅ POSIX-native
Interactive audit mode	❌	⚠️ Limited	✅ `-p` + `-t`

CASE STUDY

How Nexus Infra cut their CI pipeline from 47 minutes to 6.

Nexus Infra ran 3,200+ integration tests sequentially in their CI. Each test required spinning up an isolated container, running assertions, and tearing down. The for-loop approach was "good enough" — until their test suite crossed the 40-minute mark.

By replacing the bash loop with a single Argonaut invocation using -P 16 --process-slot-var=SLOT -n 1, they parallelized across 16 slots with process-level isolation. Each worker wrote results to /tmp/results-$SLOT, completely eliminating output contention.

87% Reduction in CI time

0 Lines of orchestration code

16 Parallel process slots

PRICING

Parallelism scales with your plan.

Serial execution is free forever. Unlock more process slots as your orchestration needs grow.

Open Source

$0/mo

Serial execution for individuals

✓ Serial execution (-P 1)
✓ Argument batching (-n, -L)
✓ Null-safe input (-0)
✓ Template substitution (-I)
✓ Verbose / trace mode
✗ Parallel execution
✗ Process slot variables

Get Started

Pro

$29/mo

Parallelism for power users

✓ Everything in Open Source
✓ Parallel execution up to -P 4
✓ Custom delimiters (-d)
✓ Interactive mode (-p)
✓ Empty input guard (-r)
✓ Max command-line length (-s)
✗ Process slot variables

Start Free Trial

Loved by engineers who hate slow pipelines.

"We replaced a 200-line bash script with a single Argonaut invocation. Eight parallel slots, null-safe input, process isolation — the whole thing is just one pipe."

Priya Hussain

Staff SRE, Distributed Systems

"The --process-slot-var feature alone justified our entire migration. Every worker gets a unique slot ID — we use it for temp file isolation, log routing, port allocation. It's absurdly elegant."

Ananya K

Principal Engineer, Platform Infra

"We went from sequential deployments to 16-way parallel with zero code changes to our deploy scripts. The -I {} templating just works. Our deploy went from 45 minutes to under 4."

Eren Okonkwo

DevOps Lead, FinStack

"The -p interactive mode is underrated. During incident response, we pipe suspect processes and Argonaut prompts us before each kill. It's the difference between confidence and catastrophe."

Deepa Lakshman

Security Engineer, ThreatOps

"I was hand-rolling parallel batch jobs in Python. Then I discovered Argonaut and realized the entire orchestration layer was one line of shell. Deleted 400 lines of Python that day."

Daniel Kovacs

Backend Engineer, DataForge

LIVE DEMO

See Argonaut in action.

Real command output. Real orchestration patterns.

Parallel File Cleanup

cleanup.sh

$ find /tmp -name core -type f -print0 | argonaut -0 /bin/rm -f

Safely removes files with spaces or special characters in names using null-terminated input.

Batched User Listing

users.sh

$ cut -d: -f1 < /etc/passwd | sort | argonaut echo _apt avahi backup bin daemon games gnats irc list lp mail man messagebus news nobody operator pollinate proxy root sshd sync sys syslog uucp www-data

Compact listing of all system users, batched into minimal echo invocations.

Parallel Container Build

build.sh

$ ls services/ | argonaut -I {} -P 4 docker build -t {}:latest ./services/{} [+] Building auth-service... [+] Building api-gateway... [+] Building billing-engine... [+] Building notification-svc... ✓ 4 images built in parallel

Build multiple Docker images in parallel using template substitution and 4 process slots.

FAQ

Common questions.

How does Argonaut differ from a simple for loop? ▸

A for loop processes items sequentially and spawns a new shell process per iteration. Argonaut batches multiple arguments into a single command invocation (reducing exec overhead), supports parallel execution with -P, handles special characters with null-termination, and respects system command-line length limits automatically.

Can I dynamically adjust parallelism at runtime? ▸

Yes. When running with -P, send SIGUSR1 to increase the number of concurrent processes or SIGUSR2 to decrease. This allows live tuning without restarting the pipeline — useful for responding to load changes during long-running batch jobs.

What happens if one of the commands fails? ▸

Argonaut handles failure gracefully. If any invocation exits with status 1–125, it records the failure and exits with status 123. If a command exits with status 255, Argonaut halts immediately without reading further input. Exit codes 126 and 127 are reserved for "command cannot be run" and "command not found" respectively.

How do I handle filenames with spaces or newlines? ▸

Use the -0 flag with null-terminated input. Pair it with find -print0 to produce null-delimited output. This ensures every filename is processed correctly regardless of whitespace, quotes, or backslashes in the name.

What is --process-slot-var and when should I use it? ▸

It sets an environment variable to a unique value in each parallel child process. Slot values are reused when a process exits. Use it for distributing work across resources — temp directories, ports, log files — without collision. Essential for any parallel workload that writes to shared infrastructure.

Build. Batch. Execute. At any scale.