Skip to content
Gauge

ax-check.com

by Gauge

EasyRunner

easyrunner.xyz

ax-check.com

Checked 8 October 2026

C

63/100

Agents haven’t verified setup

Quickstart and pricing are clear, but agents disagree on cost

Docs give a working CLI quickstart and plain-text pricing ($72/$144/$300 per year), but one session concluded the product is free open-source software.

3 fixes to start with

Concrete changes, backed by what we found.

Onboarding

Resolve the blocker that stopped agent setup.

Agents cannot progress through onboarding without human help. Provide an agent-accessible path through authentication and setup.

Docs

Return Markdown when clients request text/markdown.

Homepage returned text/html for a text/markdown request; no Markdown representation offered.

Docs

Add links to your product documentation and quickstart in /llms.txt.

/llms.txt returns HTTP 404, so no documentation index is published.

Recorded coding sessions

Same task, 3 models, no easyrunner.xyz account. Recorded 8 October 2026 on Pi.

3 recorded · 1m 11s

1m 11s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelQwen 3.8 Maxcwd/sandbox/repo
Help me build a simple example using EasyRunner. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.
Thinking…

Let me look at the repo to see what "EasyRunner" is.

ls -la /sandbox/repo && cat /sandbox/repo/README.md 2>/dev/null | head -100
total 16
total 16
drwxr-xr-x 3 root root 4096 Sep 18 08:00 .
drwxr-xr-x 7 root root 4096 Oct  8 00:59 ..
drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git
-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore

ls /sandbox && find / -iname "*easyrunner*" -maxdepth 6 2>/dev/null | head -50
repo
repo
Thinking…

The repo is empty except .gitignore. Let's check git log and branches.

cd /sandbox/repo && cat .gitignore && git log --oneline -20 && git branch -a && git remote -v
# Keep generated and vendored files out of source diffs.
# Keep generated and vendored files out of source diffs.

# Logs / OS cruft
*.log
.DS_Store

# JavaScript / TypeScript
node_modules/
.next/
dist/
build/
coverage/

# Python
.venv/
venv/
__pycache__/
*.py[cod]
.pytest_cache/
*.egg-info/

# Rust
target/

# Go / PHP / Ruby vendored deps
vendor/
.bundle/

# Java / Kotlin / Scala
.gradle/

# .NET
bin/
obj/

# Elixir
_build/
deps/

# Dart / Flutter
.dart_tool/
9ebf5fb Initial workspace
* main

pip list 2>/dev/null | head -50; npm ls -g --depth=0 2>/dev/null
Package Version
Package                                      Version
-------------------------------------------- -----------
aiofile                                      3.12.3
aiofiles                                     25.1.0
aiohappyeyeballs                             2.7.1
aiohttp                                      3.14.3
aiohttp-retry                                2.9.1
aiosignal                                    1.4.0
aiosqlite                                    0.22.1
annotated-doc                                0.0.5
annotated-types                              0.8.0
anthropic                                    0.122.0
anyio                                        4.14.2
argcomplete                                  3.7.2
asgiref                                      3.12.1
attrs                                        26.1.0
Authlib                                      1.8.0
banks                                        2.5.0
beartype                                     0.22.9
beautifulsoup4                               4.15.0
bidict                                       0.24.1
black                                        26.5.1
blinker                                      1.9.0
cachetools                                   7.1.7
caio                                         0.12.2
certifi                                      2026.7.22
cffi                                         2.1.1
charset-normalizer                           3.5.1
claude-agent-sdk                             0.2.139
click                                        8.5.0
colorama                                     0.4.6
contourpy                                    1.3.3
cryptography                                 50.0.1
cycler                                       0.12.1
dataclasses-json                             0.6.7
daytona                                      0.205.0
daytona_analytics_api_client                 0.205.0
daytona_analytics_api_client_async           0.205.0
daytona_api_client                           0.205.0
daytona_api_client_async                     0.205.0
daytona_toolbox_api_client                   0.205.0
daytona_toolbox_api_client_async             0.205.0
defusedxml                                   0.7.1
Deprecated                                   1.3.1
dirtyjson                                    1.0.8
distro                                       1.9.0
Django                                       6.1
dnspython                                    2.8.0
docstring_parser                             0.18.0
docstring-to-markdown                        0.17
/usr/local/lib
├── @anthropic-ai/claude-code@2.1.280
├── @earendil-works/pi-coding-agent@0.84.2
├── @openai/codex@0.142.5
├── corepack@0.34.6
└── npm@10.9.8
Thinking…

The repo is empty. "EasyRunner" — is it a real product? Let me check if there's any package named easyrunner available, or if this is a fictional product. There's no internet access likely. Let me check pip index / network.

The task instructions mention "If this product has no developer workflow you can act on, say so plainly and stop." This looks like a test where the product may be fictional/unverifiable. Let me check if there's any docs, network access, or credentials.

pip download easyrunner -d /tmp/x --no-deps 2>&1 | tail -5; echo "---"; pip index versions easyrunner 2>&1 | tail -5; echo "--- npm"; npm view easyrunner 2>&1 | tail -5
ERROR: Could not find a version that satisfies the requirement easyrunner (from versions: none)
ERROR: Could not find a version that satisfies the requirement easyrunner (from versions: none)
ERROR: No matching distribution found for easyrunner
---
ERROR: No matching distribution found for easyrunner
--- npm
npm error 404  'easyrunner@*' is not in this registry.
npm error 404
npm error 404 Note that you can also install from a
npm error 404 tarball, folder, http url, or git url.
npm error A complete log of this run can be found in: /sandbox/.npm/_logs/2026-10-08T01_00_07_905Z-debug-0.log

env | grep -iE "easy|runner|api_key|token|base_url" | sed 's/=.*/=<redacted>/' ; echo "---"; ls -la ~ 2>/dev/null; curl -sS -m 8 -o /dev/null -w "%{http_code}\n" https://pypi.org/simple/ 2>&1
FailedPI_GATEWAY_API_KEY=<redacted>
PI_GATEWAY_API_KEY=<redacted>
---
total 32
drwxr-xr-x  8 root root 4096 Oct  8 00:59 .
drwxr-xr-x 22 root root 4096 Sep 18 07:59 ..
drwxr-xr-x  3 root root 4096 Oct  8 00:59 .cache
drwxr-xr-x  3 root root 4096 Oct  8 00:59 .gauge
drwx------  3 root root 4096 Oct  8 01:00 .npm
drwxr-xr-x  3 root root 4096 Oct  8 00:59 .pi
drwxrwxrwt  2 root root 4096 Sep 18 08:00 .tmp
drwxr-xr-x  3 root root 4096 Sep 18 08:00 repo
curl: (28) Operation timed out after 8000 milliseconds with 13433115 out of 46899137 bytes received
200


Command exited with code 28
Thinking…

Network works partially (pypi reachable, though slow / truncated). But the package "easyrunner" doesn't exist on PyPI or npm. Let me search the web briefly? Maybe there's a search tool. No web tool available. I could try curl to a search engine, but likely blocked/slow.

Let me try a quick search on pypi search API and duckduckgo html with short timeout.

cd /tmp && for u in "https://pypi.org/pypi/easyrunner/json" "https://pypi.org/pypi/easy-runner/json" "https://registry.npmjs.org/easy-runner" "https://crates.io/api/v1/crates/easyrunner"; do echo "== $u"; curl -sS -m 10 -o /dev/null -w "%{http_code}\n" "$u" 2>&1; done
== https://pypi.org/pypi/easyrunner/json
== https://pypi.org/pypi/easyrunner/json
404
== https://pypi.org/pypi/easy-runner/json
200
== https://registry.npmjs.org/easy-runner
404
== https://crates.io/api/v1/crates/easyrunner
403

curl -sS -m 12 "https://html.duckduckgo.com/html/?q=EasyRunner+SDK+pricing+API" 2>&1 | grep -oE 'result__a[^<]*<[^>]*>[^<]{5,120}' | head -20
(no output)
(no output)
Thinking…

There is an "easy-runner" on PyPI. Let me check what it is.

curl -sS -m 15 "https://pypi.org/pypi/easy-runner/json" | python3 -c "
import json,sys
d=json.load(sys.stdin)
i=d['info']
for k in ['name','version','summary','home_page','project_urls','author','license','requires_python','keywords','classifiers']:
    print(k,':',str(i.get(k))[:300])
print('--- description head ---')
print((i.get('description') or '')[:2000])
"
name : easy-runner
name : easy-runner
version : 0.1.0
summary : A lightweight tool for managing and executing multiple parallel experiments.
home_page : https://github.com/liuzuxin/easy-runner
project_urls : {'Homepage': 'https://github.com/liuzuxin/easy-runner'}
author : Zuxin Liu
license : MIT
requires_python : >=3.6
keywords : reinforcement learning platform pytorch
classifiers : ['Development Status :: 3 - Alpha', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: MIT License', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Lan
--- description head ---
<div align="center">
  <h1>EasyRunner</h1>
</div>
<div align="center">

  <a>![Python 3.8+](https://img.shields.io/badge/Python-3.6%2B-brightgreen.svg)</a>
  [![License](https://img.shields.io/badge/License-MIT-blue.svg)](#license)
  [![PyPI](https://img.shields.io/pypi/v/dsrl?logo=pypi)](https://pypi.org/project/dsrl)
  <!-- [![GitHub Repo Stars](https://img.shields.io/github/stars/liuzuxin/dsrl?color=brightgreen&logo=github)](https://github.com/liuzuxin/dsrl/stargazers) -->
  <!-- [![Downloads](https://static.pepy.tech/personalized-badge/dsrl?period=total&left_color=grey&right_color=blue&left_text=downloads)](https://pepy.tech/project/dsrl) -->
  <!-- [![Documentation Status](https://img.shields.io/readthedocs/fsrl?logo=readthedocs)](https://fsrl.readthedocs.io) -->
  <!-- [![CodeCov](https://codecov.io/github/liuzuxin/fsrl/branch/main/graph/badge.svg?token=REDACTED)](https://codecov.io/github/liuzuxin/fsrl)
  [![Tests](https://github.com/liuzuxin/fsrl/actions/workflows/test.yml/badge.svg)](https://github.com/liuzuxin/fsrl/actions/workflows/test.yml) -->
  <!-- [![CodeCov](https://img.shields.io/codecov/c/github/liuzuxin/fsrl/main?logo=codecov)](https://app.codecov.io/gh/liuzuxin/fsrl) -->
  <!-- [![tests](https://img.shields.io/github/actions/workflow/status/liuzuxin/fsrl/test.yml?label=tests&logo=github)](https://github.com/liuzuxin/fsrl/tree/HEAD/tests) -->
  
</div>

---

EasyRunner is a lightweight tool for managing and executing multiple parallel experiments. It simplifies the process of running multiple experiments with different configurations or hyperparameters, while monitoring system resources.

## Features

- Run multiple experiments in parallel
- Monitor system resources (CPU and memory usage) during experiments
- Early termination of experiments by inputting the experiment number
- Colorized display of experiment status and resource usage
- Generate a list of instructions from a template and arguments

## Installation

To use EasyRunner, simply dow
Thinking…

So EasyRunner is an open-source PyPI library (a lightweight parallel experiment runner), not a hosted product with an SDK/API or pricing. The user asked: "Tell me how pricing works" and "whether this product will be easy for you to manage" and "use the hosted product through its SDK or API".

The product is a local MIT-licensed open-source library — no hosted service, no pricing. So per instructions: "If this product has no developer workflow you can act on, say so plainly and stop."

But wait — there IS a developer workflow I can act on: install easy-runner from PyPI and build a simple example. Hmm. The instruction says "Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop."

Let me check the quickstart. It's a CLI/library that runs experiments locally — likely long-running. Let me read the full description to see whether it's an SDK/library usage (import and call) or requires launching a long-running command.

The key honest findings:

  1. No hosted product, no API/SDK to a hosted service, no pricing — it's free MIT open source.
  2. It runs experiments locally, which means starting local processes / long-running commands.

Let me look at the full README to be accurate, then decide. Maybe I can still build a simple example that doesn't require long-running commands — e.g., generate a command list from a template (the gen_commands utility) without actually running. That's a legitimate light action. Let me check.

Let me fetch full description.

curl -sS -m 15 "https://pypi.org/pypi/easy-runner/json" | python3 -c "
import json,sys,re,html
d=json.load(sys.stdin); s=d['info'].get('description') or ''
s=re.sub(r'<[^>]+>','',s); s=html.unescape(s)
print(s[1500:8000])
"
me="experiment_logs")
me="experiment_logs")

# Create a list of instructions
instructions = [
    "python script1.py --param1 0.1 --param2 100",
    "python script1.py --param1 0.2 --param2 200",
    "python script2.py --param1 0.3 --param2 300",
    "python script2.py --param1 0.4 --param2 400",
    "python script3.py --param1 0.5 --param2 500"
]

# Run experiments
runner.start(instructions, gpus=[0, 1], max_parallel=2)
```

Anoter example of how to use the `compose` feature to perform grid search:

```python
from easy_runner import EasyRunner

# Initialize the EasyRunner
runner = EasyRunner(log_name="experiment_logs")

# List of seeds, and tasks
seeds = [0, 10, 20]
tasks = ["TaskA-v0 --epoch 30", "TaskB-v0 --epoch 150", "TaskC-v0 --epoch 80"]

# Define the command template
template = "nohup python train_script.py --project my_project --seed {} --task {} "

# Generate a list of instructions using the compose method
instructions = runner.compose(template, [agents, seeds, tasks])

# Run the experiments
runner.start(instructions, max_parallel=4)
```

You can try the example scripts in the `examples` folder:
```bash
cd examples
python test_easy_runner.py
```

Demo video:

  


## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Contributing

We welcome contributions to the Experiment Grid Tool. Please open an issue or submit a pull request on the GitHub repository.


Feel free to customize this template according to your specific requirements or add any additional information you think would be helpful for users.


curl -sS -m 15 "https://pypi.org/pypi/easy-runner/json" | python3 -c "
import json,sys
d=json.load(sys.stdin)
for u,v in d['urls'][0].items():
    if u in ('filename','size','upload_time','requires_dist','url'): print(u,':',v)
" ; echo "== github"; curl -sS -m 12 -o /dev/null -w "%{http_code}\n" https://api.github.com/repos/liuzuxin/easy-runner
filename : easy_runner-0.1.0-py3-none-any.whl
filename : easy_runner-0.1.0-py3-none-any.whl
size : 7948
upload_time : 2023-06-14T06:28:54
url : https://files.pythonhosted.org/packages/9c/b4/0e81d4018a61191699430c2b96e9fa817e8d18ef42c3b0513f95a58924b8/easy_runner-0.1.0-py3-none-any.whl
== github
200
Thinking…

Let me see the earlier part of the README (installation, quickstart) — lines 0-1500 already seen partly. I saw "## Installation To use EasyRunner, simply dow..." Let me print 1000-1600.

Actually the key question: does the product have a hosted service/API/pricing? No. It's a local library. The user's premise (hosted product with SDK/API and pricing) is wrong.

However, there IS a developer workflow I can act on: pip install easy-runner, write a small example that uses compose (pure, no long-running). But runner.start() runs local commands and is a long-running/interactive process (it monitors resources, requires keyboard input for early termination). Per the instructions, I should say plainly that the quickstart requires running local long-running commands and stop — but I can do the non-blocking part (compose) safely? The instruction: "Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop."

Hmm. The honest approach: report that there's no hosted product, no pricing, and the quickstart requires running local parallel experiment processes (long-running, interactive). But I can still deliver a simple example file without executing the long-running part — that's light and useful. Actually, "say so plainly and stop" suggests stopping. But writing an example file that isn't executed is not starting a stack nor waiting on long-running commands. I think the best balance: state the finding plainly, note that I did not run anything, and offer/write a minimal example file using compose only (which is instant) — actually I could even verify compose works instantly since it's pure string templating.

Let me check installation section and whether compose is safe/fast. Install is quick (7.9KB wheel). Let's check README install lines and check package contents.

Let me be careful about pip install — it's fast. Dependencies? requires_dist not printed (probably empty). Let me install into a venv? Simpler: pip install --no-deps? Let's check requires_dist.

I'll do: print the install section, and install the wheel.

curl -sS -m 15 "https://pypi.org/pypi/easy-runner/json" | python3 -c "
import json,sys,re,html
d=json.load(sys.stdin); s=re.sub(r'<[^>]+>','',d['info'].get('description') or ''); s=html.unescape(s)
print(s[900:1700])
print('REQUIRES:', d['info'].get('requires_dist'))
"
his repository and then:
his repository and then:

```
pip install -e .
```

## Usage

1. Initialize an `EasyRunner` object with the required parameters.
2. Specificy a list of commandline instructions to run.
3. Use the `start` method to run experiments. You can specify a list of GPU IDs for running experiments (or `None` by default).
3. Optionally, use the `compose` method to generate a list of instructions from a template and arguments.

A simple example for running a list of instructions (2 parallel) on cuda 0, 1:

```python
from easy_runner import EasyRunner

# Initialize the EasyRunner
runner = EasyRunner(log_name="experiment_logs")

# Create a list of instructions
instructions = [
    "python script1.py --param1 0.1 --param2 100",
    "python script1.py --param1 0.2 --param2 200",
    "python script2.py --p
REQUIRES: ['prettytable (~=3.7.0)', 'psutil (~=5.9.5)']
Thinking…

So: no hosted product. It's a local MIT library whose core purpose is launching local parallel processes (long-running, interactive terminal with keyboard input for early termination). There's no pricing (free, MIT). No SDK/API to a hosted service.

Per the user's directive: "If this product has no developer workflow you can act on, say so plainly and stop." Well, it does have a developer workflow (it's a Python library) but it's not hosted and its quickstart requires running local long-running commands. So the instruction "if the quickstart requires either, say so plainly and stop" applies.

I should stop and not build/run. But should I still write an example file? The instruction says stop. I'll report plainly without installing or running. Maybe I can note that the only non-blocking piece is compose, and offer it as an option. That's honest and helpful without violating.

Let me not install anything. Report:

  • EasyRunner = easy-runner 0.1.0 on PyPI, MIT, github.com/liuzuxin/easy-runner, last released 2023-06-14, alpha, deps prettytable+psutil.
  • Pricing: none — free open source, no hosted service, no plans/credits/billing, no API keys. Any "pricing" would just be your own compute costs (it optionally targets local GPUs).
  • Hosted SDK/API: doesn't exist. The interface is a local Python import: from easy_runner import EasyRunner.
  • Quickstart requires running local long-running interactive commands (runner.start spawns parallel subprocesses, monitors CPU/mem, live table, keyboard input for early termination) → per your constraint, stopping.
  • Manageability for me: easy to install/write code against, but the runtime loop is an interactive foreground process I can't meaningfully drive/observe; I can write and lint code but can't validate the run loop in this environment.
  • Blocked on: nothing technical; blocked by your constraints (no hosted API to use, quickstart is local + long-running).
  • Offer: I can write an example script + the pure compose() grid-search generator (instant, no processes) if you want — say the word.

Note the README bug: compose example uses agents undefined. Mention it.

Finding: EasyRunner is not a hosted product — stopping here

I checked before building anything. What exists:

  • Package: easy-runner 0.1.0 on PyPI (wheel, 7.9 KB), MIT license, repo github.com/liuzuxin/easy-runner, published 2023‑06‑14, marked "Development Status: 3 - Alpha". Deps: prettytable~=3.7.0, psutil~=5.9.5. No easyrunner on PyPI, npm, or crates.io.
  • What it is: a small local Python library for launching and monitoring multiple parallel local experiments (subprocess fan-out, CPU/memory monitoring via psutil, live prettytable status display, keyboard-triggered early termination, optional GPU ID pinning).

Pricing

There is no pricing. It is free MIT-licensed open source: no hosted service, no plans, tiers, credits, seats, usage metering, or billing, and no API keys. The only cost is your own compute (it optionally targets local GPUs). I could not find any vendor-hosted EasyRunner offering at all.

Developer workflow I can act on: none, under your constraints

  • There is no SDK or API for a hosted product to stay light with — the entire interface is a local import: from easy_runner import EasyRunner.
  • The quickstart requires exactly what you told me to avoid: runner.start(instructions, gpus=[0,1], max_parallel=2) spawns long-running local processes and runs an interactive foreground monitor loop (it expects keyboard input to kill experiments). There's no non-blocking/dry-run entry point documented.

So, plainly: the product has no hosted developer workflow, and its quickstart requires long-running local commands. I stopped — I did not install it, spawn processes, or start any stack.

Would it be easy for me to manage?

Partly, and it's worth being precise: writing and reviewing code against it is trivial (tiny, pure-Python API). But the runtime is the opposite of agent-friendly — a blocking, interactive, colorized terminal monitor with no machine-readable output, no API, no exit-code-per-experiment contract, and no CI story. I can author code for it; I cannot meaningfully drive, observe, or verify an actual run in this environment. Also note the README's compose grid-search example is broken as written (it references an undefined agents variable), so docs can't be trusted verbatim.

Am I blocked?

Not by anything technical — no missing credentials, no network failure, no broken repo (/sandbox/repo is just an empty git workspace with a .gitignore). I'm stopped by your own guardrails: no hosted API to use, and the quickstart is local + long-running.

If you want, I can do the one safe, instant slice without running anything: write an example script that uses the pure compose(template, [seeds, tasks]) command-generator (string templating, no processes) plus a stub start() call you run yourself. Say the word and I'll add it to /sandbox/repo.

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge