# Langflow langflow 1.13.0: our test log

Canonical: https://theagenticweekly.com/tests/langflow · Last verified: 2026-10-26 · Published: 2026-10-26 · Author: Agentic Weekly (operated independently from Texas, US) · Evidence: Tested by us on 2026-10-26. Local open-weight model, not the vendor's hosted models. A smoke test on a CPU-only box, not a benchmark.

> Langflow 1.13.0 installed in 19.76 s (1.7 GB) and its backend was healthy 91.5 s after launch, serving 26 starter flows and 416 components.

## Result at a glance

Table: Langflow test record

| Field | Value |
|---|---|
| Result | Passed |
| Version tested | langflow 1.13.0 |
| Date and time | 2026-10-26, 09:57 CDT (America/Chicago) |
| Task | Install Langflow with uv, start the backend (no UI) with a fresh SQLite database and auto-login, then check GET /health_check, GET /api/v1/version, the list of flows, and the component catalogue. Pass means the server reports healthy and the API answers. No flow was run and no model was used. |
| Model used | none (no language model involved) |
| Hardware | Linux x86_64 virtual machine (Debian 13), 8 vCPU (Intel Xeon, 1 thread per core), 15 GiB RAM, no GPU |
| Install | 19.76 s, 1725 MB (langflow 1.13.0) |
| Time to healthy | 91.5 s (shared machine) |
| Starter flows / components | 26 / 416 |

## What we found

- /health_check returned status ok for chat and db after 91.5 s.
- A fresh database already contained 26 starter flows (for example Text Sentiment Analysis, Social Media Agent, Simple Agent, Multi Agent Flow).
- The component catalogue returned 416 components in 33 categories in 1.39 s.

## What we ran, step by step

Table: Commands run, wall-clock time and exit code

| Step | Wall time | Exit code | Notes |
|---|---|---|---|
| Install with uv (cold, no cache) | 19.76 s | 0 | langflow 1.13.0; 1725 MB on disk. A first attempt failed with 'No space left on device' because this machine's disk was full, not because of Langflow; the retry succeeded. Load 13.39. |
| Task command (start server, probe API) | 1 min 34 s | 0 | Healthy after 91.5 s with load 20.72 (heavily shared machine). |

Exact commands (paths shortened)

```
# Install with uv (cold, no cache)
uv venv -q -p 3.13 work/py/langflow && VIRTUAL_ENV=work/py/langflow uv pip install --no-cache -q langflow && du -sm work/py/langflow | cut -f1 && VIRTUAL_ENV=work/py/langflow uv pip list 2>/dev/null | grep -i -E "^(langflow|langflow) "

# Task command (start server, probe API)
work/py/langflow/bin/langflow run --host 127.0.0.1 --port 7861 --backend-only (driven by tasks3/langflow_task.py)
```

## Raw output (excerpts)

Probe results

```
{
 "health": [
  200,
  "{\"status\":\"ok\",\"chat\":\"ok\",\"db\":\"ok\"}"
 ],
 "ready_s": 91.5,
 "version": {
  "version": "1.13.0",
  "main_version": "1.13.0",
  "package": "Langflow"
 },
 "flows": 26,
 "flow_names": [
  "Text Sentiment Analysis",
  "Social Media Agent",
  "Simple Agent",
  "Multi Agent Flow",
  "SEO Keyword Generator",
  "Market Research",
  "Sequential Tasks Agents",
  "Blog Writer"
 ],
 "components_s": 1.39,
 "component_categories": 33,
 "component_count": 416
}
```

The task script (tasks3/langflow_task.py)

```
import subprocess, time, json, urllib.request, os, sys, signal
env = dict(os.environ, LANGFLOW_CONFIG_DIR="/workspace/tests2/work/langflow-home", LANGFLOW_DATABASE_URL="sqlite:////workspace/tests2/work/langflow-home/lf.db", LANGFLOW_AUTO_LOGIN="true", DO_NOT_TRACK="true", LANGFLOW_DO_NOT_TRACK="true", LANGFLOW_OPEN_BROWSER="false")
t0 = time.perf_counter()
p = subprocess.Popen(["work/py/langflow/bin/langflow", "run", "--host", "127.0.0.1", "--port", "7861", "--backend-only", "--no-open-browser"], env=env, stdout=open("/workspace/tests2/logs/langflow-server.log", "w"), stderr=subprocess.STDOUT, preexec_fn=os.setsid)
def get(path, hdr=None):
    r = urllib.request.Request("http://127.0.0.1:7861" + path, headers=hdr or {})
    with urllib.request.urlopen(r, timeout=10) as x: return x.status, x.read()
res = {}
ready = None
while time.perf_counter() - t0 < 600:
    if p.poll() is not None: res["died"] = p.returncode; break
    try:
        s, b = get("/health_check"); ready = round(time.perf_counter() - t0, 1); res["health"] = [s, b.decode()[:120]]; break
    except Exception: time.sleep(2)
res["ready_s"] = ready
if ready:
    s, b = get("/api/v1/version"); res["version"] = json.loads(b)
    s, b = get("/api/v1/auto_login"); tok = json.loads(b)["access_token"]
    s, b = get("/api/v1/flows/?get_all=true&header_flows=true", {"Authorization": "Bearer " + tok})
    fl = json.loads(b); res["flows"] = len(fl); res["flow_names"] = [f["name"] for f in fl][:8]
    t = time.perf_counter(); s, b = get("/api/v1/all", {"Authorization": "Bearer " + tok}); res["components_s"] = round(time.perf_counter() - t, 2)
    try:
        d = json.loads(b); res["component_categories"] = len(d); res["component_count"] = sum(len(v) for v in d.values())
    except Exception as e: res["components_err"] = str(e)[:100]
os.killpg(os.getpgid(p.pid), signal.SIGTERM)
print("RESULT_JSON " + json.dumps(res))
```

## Gotchas and things that broke

- The install is large: 1.7 GB on disk, the biggest of the tools in this batch.
- The server logged an agent-card compliance warning at startup; it did not stop it.

## What we did not test

- Building or running any flow, including a flow that calls a model.
- The visual editor: we ran the backend only.
- Langflow's hosted or desktop offerings and deployment.
- Start-up time on an idle machine: ours was heavily shared.

## Reproduce it

Versions change. These commands install whatever is latest on the day you run them unless a version is pinned, so expect different results later. The version we measured is in the table above.

```
uv venv -p 3.13 .venv && VIRTUAL_ENV=.venv uv pip install langflow
LANGFLOW_AUTO_LOGIN=true .venv/bin/langflow run --backend-only --port 7861
curl http://127.0.0.1:7861/health_check
```

## How to read this test

Every number on this page was measured on this one machine, which also ran other jobs, so timings are indicative and vary run to run. A pass means our small task worked once or as stated, a fail means it did not work as we ran it; neither says how the tool behaves with a vendor's frontier model, on a GPU, or at scale. Where a tool could not run without an account or a GPU, we say so instead of guessing.

See the [testing rig](https://theagenticweekly.com/methodology#testing-rig) for the hardware, the local model and the rules we follow, and the [test hub](https://theagenticweekly.com/tests) for every other test.

## FAQ

### How big is a Langflow install?

About 1.7 GB on disk in a fresh Python 3.13 environment in our run, and it installed in about 20 s with uv.

## Sources

- [Langflow repository](https://github.com/langflow-ai/langflow) (fetched 2026-10-26)

## Related

- [All test logs](https://theagenticweekly.com/tests)
- [Methodology and testing rig](https://theagenticweekly.com/methodology#testing-rig)
- [Langflow facts and sources](https://theagenticweekly.com/tools/langflow)

## How to cite

Agentic Weekly, "Langflow langflow 1.13.0: our test log", last updated 2026-10-26, https://theagenticweekly.com/tests/langflow