StrataBench

Agentic, honest storage benchmarking for every layer — HDD, NVMe, AFA, S3, VM, and application workloads.

StrataBench is an open-source platform that orchestrates industry-standard engines (fio, SPDK, vdbench, Warp, elbencho, pgbench), validates workload design before you run, and reports unified results across physical bare metal, virtual machines, and distributed clusters.

Stop trusting benchmark numbers you haven't validated. StrataBench tells you if your test is honest — before you act on the results.

Docs: pratham-vishk.github.io/StrataBench · Container: ghcr.io/pratham-vishk/stratabench

Keywords

storage benchmark · NVMe benchmark · HDD performance · all-flash array · AFA · S3 benchmark · MinIO Warp · RDMA · fio orchestration · SPDK perf · vdbench · VM storage · HCI benchmark · PostgreSQL pgbench · Kafka throughput · distributed benchmark · multi-node · Kubernetes operator · storage validation · IOPS · latency p99 · regression testing · SMART monitoring · agentic AI · Dell lab · enterprise storage

Why StrataBench?

	fio	SPDK	Warp	vdbench	SBK	HCIBench	StrataBench
Block / NVMe	✅	✅	—	✅	—	✅	✅
HDD / SSD	✅	—	—	✅	—	✅	✅
File / parallel FS	partial	—	—	—	✅	—	✅
S3 / object + RDMA	—	—	✅	—	partial	—	✅
VM / guest workloads	manual	—	—	—	partial	✅	✅
Multi-client topologies	manual	—	partial	—	—	partial	✅
Multi-server topologies	—	—	partial	partial	—	—	✅
Pre-run validation	—	—	—	—	—	—	✅
Unified reporting	—	—	—	—	—	—	✅
Agentic NL → report	—	—	—	—	partial	—	✅
Regression baselines	—	—	—	—	—	—	✅

One platform. Every storage layer. Honest numbers.

What works today

Storage layers & engines

Layer	Engines	Physical	Virtual (VM)
Block	fio, SPDK, vdbench	HDD, SSD, NVMe, AFA multi-LUN	fio via SSH, NVMe passthrough
File	elbencho	NFS, Lustre, CephFS	elbencho in guest via SSH
Object	MinIO Warp	S3 PUT/GET, mixed, cluster, RDMA	MinIO in VM, S3 RDMA
Application	pgbench, db_bench, kafka-perf	PostgreSQL, RocksDB, Kafka	agent on guest VM
Mock	synthetic	`--mock` on any profile	`--mock` on any profile

Priority workloads — physical and virtual

Workload	Physical	Virtual
HDD	`hdd-sequential-read`	`vm-hdd-sequential`
NVMe	`nvme-random-oltp`, `nvme-max-stress`, `spdk-nvme-peak`	`vm-nvme-oltp`, `vm-nvme-passthrough`
AFA	`afa-multi-lun`	`vm-afa-multi-lun`
S3 RDMA	`s3-cluster-rdma`	`vm-s3-rdma`

Distributed topologies — all scenarios

Scenario	Flag	Mode
1 client → 1 server	`--target`	`single`
N clients → 1 server	`--clients`	`pool`
1 client → N servers	`--targets`	`sweep`
N clients → M servers	`--clients` + `--targets`	`shard`
N clients × M servers	`--topology matrix`	`matrix`

Platform features

Validator — cache size, steady state, tail latency rules before every run
33 workload profiles — declarative YAML, extensible
Agentic loop — stratabench agent "nvme oltp database" → plan → validate → run → analyze → report
MCP server — stratabench-mcp exposes 14 tools for Cursor, Claude, and other CLI models
LLM planner — Ollama or OpenAI-compatible APIs; keyword fallback
Regression tracking — explicit baselines + 30-day rolling comparison
Branch compare — benchmark two git branches, HTML impact report (compare branches)
Hardware inventory — NVMe model, firmware, block devices, SMART history
REST API + Prometheus metrics + Grafana dashboard
Kubernetes — CRD, in-cluster operator, DaemonSet agents, CronJobs
Cross-layer analysis — compare block vs object vs app in one report
SBK import — ingest Storage Benchmark Kit CSV or JSON results
Async runs — --async / API async: true with stratabench watch and live Prometheus progress

Quick start

Install

git clone https://github.com/pratham-vishk/StrataBench.git
cd StrataBench
make build
stratabench init

Or pull the container:

docker pull ghcr.io/pratham-vishk/stratabench:latest
docker run --rm ghcr.io/pratham-vishk/stratabench:latest version

Run (no hardware required)

# List built-in profiles
./bin/stratabench profiles

# Mock run — works on Windows, macOS, Linux
./bin/stratabench run --profile nvme-random-oltp --target /dev/null --mock

# Sample benchmark — same flow, copies HTML/Excel/JSON to examples/sample-report/output/
./bin/stratabench sample --open-report
# or: make sample

# Full agentic loop
./bin/stratabench agent "ssd random 4k workload" --target /tmp/test --mock

Use with CLI models (Cursor, Claude Code, Devin)

Claude Code and Devin work out of the box — clone the repo; MCP configs are committed (.mcp.json, .devin/mcp_config.json).

make build-mcp   # optional; go run works via .mcp.json

Platform	Setup
Claude Code	Open repo → approve `stratabench` MCP (`/mcp`)
Devin	Clone repo → reads `AGENTS.md` + `CLAUDE.md` + `.devin/mcp_config.json`
Claude Desktop	Merge `examples/mcp-claude-desktop.json`
Cursor	Add `examples/mcp-cursor.json` to MCP settings

See AGENTS.md and docs/AGENTIC.md for full setup.

# LLM planner (Ollama local or OpenAI-compatible)
export OPENAI_API_KEY=sk-...   # or: ollama serve
./bin/stratabench plan "s3 rdma cluster" --llm
./bin/stratabench agent "afa multi lun" --target /dev/sdb --llm --mock

Run on real storage (Linux)

# NVMe OLTP — workload + hardware validation (on by default)
./bin/stratabench validate --profile nvme-random-oltp --target /dev/nvme0n1 --cache-bytes 34359738368
./bin/stratabench run --profile nvme-random-oltp --target /dev/nvme0n1

# AFA multi-LUN
./bin/stratabench run --profile afa-multi-lun --target /dev/sdb,/dev/sdc,/dev/sdd

# S3 cluster with RDMA
export WARP_ACCESS_KEY=minioadmin WARP_SECRET_KEY=minioadmin
./bin/stratabench run --profile s3-cluster-rdma --target 10.0.1.10:9000

# VM guest (fio inside VM via SSH)
./bin/stratabench run --profile vm-nvme-passthrough --target root@10.0.1.20:/dev/nvme0n1

Distributed — multi-client, multi-server

# Start agents on client nodes
stratabench-agent   # listens on :7777

# N clients → 1 NVMe server (pool)
stratabench run --profile ssd-random-4k --target /dev/nvme0n1 \
  --clients 10.0.1.1:7777,10.0.1.2:7777,10.0.1.3:7777

# 1 client → N S3 servers (sweep)
stratabench run --profile s3-put-throughput \
  --targets 10.0.1.10:9000,10.0.1.11:9000,10.0.1.12:9000

# N clients → M servers (shard)
stratabench run --profile afa-multi-lun \
  --targets /dev/sdb,/dev/sdc,/dev/sdd \
  --clients 10.0.1.1:7777,10.0.1.2:7777,10.0.1.3:7777 \
  --topology shard

Distributed — multi-client, multi-server

# Start agents on client nodes
stratabench-agent   # listens on :7777

# N clients → 1 NVMe server (pool)
stratabench run --profile ssd-random-4k --target /dev/nvme0n1 \
  --clients 10.0.1.1:7777,10.0.1.2:7777,10.0.1.3:7777

# 1 client → N S3 servers (sweep)
stratabench run --profile s3-put-throughput \
  --targets 10.0.1.10:9000,10.0.1.11:9000,10.0.1.12:9000

# N clients → M servers (shard)
stratabench run --profile afa-multi-lun \
  --targets /dev/sdb,/dev/sdc,/dev/sdd \
  --clients 10.0.1.1:7777,10.0.1.2:7777,10.0.1.3:7777 \
  --topology shard

Lab cluster — one config, every engine (HDD, NVMe, AFA, S3 RDMA)

Use a single lab.yaml on your Linux jump host. StrataBench installs agents/tools once, then lab run <profile> picks the right target, topology, and engine automatically. Every run produces HTML, Excel, and PDF reports.

cp examples/lab.yaml.example lab.yaml
# Edit: clients, targets.block (/dev/sdb), servers (only for S3), s3.deploy: skip for HDD-only

make build
stratabench lab bootstrap -f lab.yaml
stratabench lab check -f lab.yaml

# Block / HDD / NVMe (uses targets.block — no S3 required)
stratabench lab run -f lab.yaml hdd-sequential-read
stratabench lab run -f lab.yaml nvme-random-oltp

# AFA multi-LUN (uses targets.afa_luns + vdbench)
stratabench lab run -f lab.yaml afa-multi-lun

# S3 + RDMA (needs servers: + MinIO; uses s3-cluster-rdma profile)
stratabench lab run -f lab.yaml s3-cluster-rdma

# Application / SBK (uses targets.postgres_dsn, kafka, etc.)
stratabench lab run -f lab.yaml app-postgres-tpc-c
stratabench sbk tools   # preflight: pgbench, db_bench, kafka-producer-perf-test on PATH

Example lab.yaml targets section:

clients:
  - host: 10.0.1.1
  - host: 10.0.1.2

targets:
  block: /dev/sdb                    # HDD / NVMe (fio)
  afa_luns: /dev/sdb,/dev/sdc        # vdbench AFA
  file: /mnt/nfs/share               # elbencho
  postgres_dsn: postgres://bench@10.0.1.5/db
  kafka: 10.0.1.30:9092

servers:                             # only for object/S3 profiles
  - host: 10.0.1.10
    port: 9000
s3:
  deploy: docker                     # use skip for HDD-only labs

You run	Layer	Engine	Target from `lab.yaml`
`hdd-sequential-read`	block	fio	`targets.block`
`nvme-random-oltp`	block	fio	`targets.block`
`afa-multi-lun`	block	vdbench	`targets.afa_luns`
`s3-put-throughput`	object	warp	`servers:9000`
`s3-cluster-rdma`	object	warp + RDMA	`servers:9000`
`file-parallel-read`	file	elbencho	`targets.file`
`app-postgres-tpc-c`	application	sbk	`targets.postgres_dsn`

See LAB-BOOTSTRAP.md and DELL-LAB.md for full cluster setup.

Natural language — plan, guide, agent (prompt → report)

Describe what you want in plain English. StrataBench maps intent to a profile, validates, runs, and writes reports.

# Suggest profile + parameters (no run)
stratabench plan "hdd sequential read on rotational disk"
stratabench guide "s3 cluster put get over rdma" --target 10.0.1.10:9000

# Full loop: plan → validate → run → analyze → HTML + Excel + PDF
stratabench agent "nvme random oltp 4k" --target /dev/nvme0n1 --clients 10.0.1.1:7777 --mock false --yes
stratabench agent "afa multi lun random read" --target /dev/sdb,/dev/sdc --yes
stratabench agent "s3 rdma cluster benchmark" --target 10.0.1.10:9000 --clients 10.0.1.1:7777 --yes

# Optional LLM planner (Ollama or OpenAI-compatible)
stratabench agent "postgres tpc-c oltp" --target postgres://localhost/bench --llm --yes

After every run, lab run, or agent completion:

Report:  ~/.stratabench/reports/<run-id>.html   # charts, intervals, node matrix
Excel:   ~/.stratabench/reports/<run-id>.xlsx
PDF:     ~/.stratabench/reports/<run-id>.pdf    # executive summary

stratabench report --run-id <uuid>              # regenerate all three
stratabench export pdf --run-id <uuid>
stratabench lab validate -f lab.yaml --check-sbk-tools

Regression & reporting

stratabench baseline set --run-id <uuid>
stratabench run --profile nvme-random-oltp --target /dev/nvme0n1 --check-baseline
stratabench report --run-id <uuid>
stratabench analyze --run-id <uuid>

Architecture

Natural language / CLI / API / Kubernetes CRD
                    │
                    ▼
         ┌──────────────────────┐
         │  Agent Layer         │
         │  Planner → Validator │
         │  → Analyst → Reporter│
         └──────────┬───────────┘
                    ▼
         ┌──────────────────────┐
         │  Orchestrator        │
         │  Topology engine     │
         │  33 YAML profiles    │
         └──────────┬───────────┘
                    ▼
    ┌───────────────┼───────────────┐
    ▼               ▼               ▼
  fio           vdbench           Warp
  SPDK          elbencho          SBK (pgbench…)
    │               │               │
    └───────────────┴───────────────┘
                    ▼
         Unified result schema
         SQLite · HTML · Excel · PDF · Prometheus

We orchestrate proven tools — we don't replace fio or Warp. We add validation, topology, aggregation, and honest reporting on top.

Deployment

Method	Command
Binary	`make build` → `./bin/stratabench`
Docker	`docker compose up api` → REST on `:8080`
Kubernetes	`kubectl apply -k deploy/k8s/`
K8s CRD	`stratabench apply -f examples/benchmark-mock.yaml`
Grafana	`deploy/grafana/stratabench-dashboard.json`

# Full K8s stack: API, agents, operator, PVC, CronJob
kubectl apply -k deploy/k8s/
kubectl apply -f examples/benchmark-topology-pool.yaml
kubectl get benchmarks -n stratabench -w

CLI reference

Command	Description
`profiles`	List workload profiles
`plan`	Suggest profile from natural language
`validate`	Check workload design + hardware for profile (`--check-hardware`)
`run`	Execute benchmark (local or distributed)
`agent`	Full agentic loop end-to-end
`apply`	Apply Kubernetes-style benchmark manifest
`baseline`	Set / show / check regression baselines
`inventory`	Collect hardware inventory
`smart`	SMART health history
`analyze`	Tail latency, variance, regression insights
`cross-layer`	Multi-profile bottleneck analysis
`lab`	Bootstrap cluster, profile-aware `lab run`, validation matrix
`sbk tools`	Probe native SBK drivers (pgbench, db_bench, kafka) on PATH
`export`	Export run as JSON, Excel, or PDF
`compare`	Compare runs (`compare runs`) or git branches (`compare branches`)
`init`	Create `.stratabench` data directories
`report`	Generate HTML, Excel, and PDF report

Flags: --profile · --target · --targets · --clients · --topology · --mock · --check-baseline · --ollama

Documentation

Doc	What's inside
ENGINE-COVERAGE.md	Every engine × physical/virtual matrix
TOPOLOGY.md	Multi-client / multi-server patterns
DEV.md	Build, test, full CLI reference
BRANCH-COMPARE.md	Compare two code branches with benchmarks
ARCHITECTURE.md	System design
LAB-BOOTSTRAP.md	One-command lab bootstrap + profile-aware run
DELL-LAB-VALIDATION.md	Hardware sign-off checklist
VISION.md	Project goals
ROADMAP.md	What's shipped vs planned
profiles/	33 workload YAML definitions

Built at Dell Technologies

StrataBench is designed for enterprise storage validation — NVMe arrays, AFA LUNs, S3 clusters with RDMA, VM workloads on HCI, and application-layer benchmarks (PostgreSQL, Kafka, RocksDB). Run it on Dell lab VMs, customer sites, or any Linux cluster.

Contributing

Contributions welcome. See CONTRIBUTING.md and CODE_OF_CONDUCT.md.

make test          # run all tests
make run-mock      # smoke test

License

Apache License 2.0 — see LICENSE.

StrataBench — honest storage benchmarks, every layer, every topology.
Documentation · Releases · Issues

Name		Name	Last commit message	Last commit date
Latest commit History 51 Commits
.cursor/skills/stratabench		.cursor/skills/stratabench
.devin		.devin
.github/workflows		.github/workflows
agents		agents
cmd		cmd
crates		crates
deploy		deploy
docs		docs
examples		examples
internal		internal
profiles		profiles
scripts		scripts
.dockerignore		.dockerignore
.gitignore		.gitignore
.mcp.json		.mcp.json
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
CLAUDE.md		CLAUDE.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
Dockerfile		Dockerfile
LICENSE		LICENSE
Makefile		Makefile
README.md		README.md
RELEASE.md		RELEASE.md
SECURITY.md		SECURITY.md
docker-compose.yml		docker-compose.yml
go.mod		go.mod
go.sum		go.sum
llms.txt		llms.txt

Navigation Menu

Repository files navigation

StrataBench

Keywords

Why StrataBench?

What works today

Storage layers & engines

Priority workloads — physical and virtual

Distributed topologies — all scenarios

Platform features

Quick start

Install

Run (no hardware required)

Use with CLI models (Cursor, Claude Code, Devin)

Run on real storage (Linux)

Distributed — multi-client, multi-server

Distributed — multi-client, multi-server

Lab cluster — one config, every engine (HDD, NVMe, AFA, S3 RDMA)

Natural language — plan, guide, agent (prompt → report)

Regression & reporting

Architecture

Deployment

CLI reference

Documentation

Built at Dell Technologies

Contributing

License

About

Releases

Packages

Contributors

Languages

Folders and files

Latest commit

History

Repository files navigation

StrataBench

Keywords

Why StrataBench?

What works today

Storage layers & engines

Priority workloads — physical and virtual

Distributed topologies — all scenarios

Platform features

Quick start

Install

Run (no hardware required)

Use with CLI models (Cursor, Claude Code, Devin)

Run on real storage (Linux)

Distributed — multi-client, multi-server

Distributed — multi-client, multi-server

Lab cluster — one config, every engine (HDD, NVMe, AFA, S3 RDMA)

Natural language — plan, guide, agent (prompt → report)

Regression & reporting

Architecture

Deployment

CLI reference

Documentation

Built at Dell Technologies

Contributing

License

About

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages