LLM Space 4: A Desktop Workbench for Building and Debugging Agent Harnesses

What LLM Space 4 Solves for Agent Builders

Agent development often suffers from a lack of visibility. You write a prompt, wire up tools, and run a loop, but when it fails you have little idea which step caused it. LLM Space 4 is a desktop application aimed at exactly that pain. It lets you prototype agent ideas, inspect every step of harness execution, debug failures by replaying runs, and evaluate performance across runs. The README describes it as a tool for agent builders, and it is the sister project of DeerFlow, which uses it heavily for development. If you are building agents and find yourself manually logging calls or re-running experiments to see what happened, this app targets that workflow directly. It is not a framework for building agents from scratch; it is a workspace around your existing harness, with a local runtime and support for plugins.

How the App Is Structured: Monorepo and Packages

The project is a Bun monorepo with a clear separation of concerns. The packages directory holds core, runtime, and ui. The core package contains shared domain types, clients, storage, and generators. The runtime package includes the local runtime, models, tools, skills, MCP, and plugins. The ui package provides a shared React design system and the Thread Playground. The apps directory contains the desktop app, which combines an Electrobun shell with React UI. The examples directory has a complete Atlas Plugin example that covers every extension type. This layout suggests that the app is not a single monolithic binary but a modular system where you can potentially reuse the core or runtime packages in your own projects, though the README does not explicitly state that as a supported use case. The separation does make the codebase navigable, and the mirrored test structure (tests beside src) indicates a disciplined approach to testing.

Getting It Running: Bun, mise, and Commands

To run LLM Space from source, you need Bun, which the README describes as a fast all-in-one runtime and package manager, a drop-in replacement for Node.js and npm. After installing Bun, you run `bun install` from the repo root. For contributors or those wanting the exact CI toolchain, the README recommends installing mise and running `mise run setup`, which installs the locked Bun version from `mise.lock` plus JS dependencies in one step. To start the desktop app for local development, you run `mise run dev`. To build a canary release, you run `mise run build:canary`. These commands are concrete and taken directly from the README. Note that there is no mention of Windows or Linux binaries; the download section only lists DMG files for macOS, both Apple Silicon and Intel. That is a significant constraint if you are not on a Mac.

The Two Editions: System WebView vs Embedded Engine

The README describes two editions of the desktop app. The standard LLM Space uses the system WebView, which results in a small download of about 27 MB and is light on memory and battery. The LLM Space Performance edition embeds its own rendering engine, making the download about 130 MB. The performance edition aims for consistent rendering across macOS versions and usually performs better. Both editions share the same `~/.llm-space` data directory, so switching between them preserves your threads and settings, and both update themselves in place. This is a thoughtful design for users who want a lightweight default but can opt into a heavier, more consistent rendering engine when needed. The trade-off is clear: small and efficient versus consistent and potentially faster. The documentation does not specify which edition is recommended for which scenario, so you may need to experiment.

Core Features: Build, Trace, Debug, Evaluate, Manage, Generate

The feature set is organized into six verbs. Build lets you write and version prompts, system messages, tools, and model settings. Trace shows every model call and tool run inside the agent loop as it happens. Debug allows replaying a run from history and stepping through it to find what went wrong. Evaluate measures agent performance across runs. Manage keeps threads organized as files on your own machine. Generate lets AI write prompts and tools for you, and can turn any thread into a runnable LangGraph agent. The last feature is notable because it bridges a prototyping tool to a production framework: you can prototype in LLM Space and then export to LangGraph. The README does not provide details on how the generation works or what the generated code looks like, but the existence of a generator in the core package suggests it is a structured process.

Local-First and Telemetry: What You Need to Know

The app is local-first: your files and API keys stay on your local computer. That is a strong privacy stance compared to cloud-based agent tools. However, the README states that LLM Space collects a small amount of anonymous usage data to improve the app, and it points to TELEMETRY.md for exactly what is collected and how to opt out. This is a caveat for those who assume local-first means no data leaves the machine. The README does not list the telemetry details, so you must read that file before using the app if you are privacy-sensitive. The data is anonymous, but it is still a data collection. The opt-out mechanism is not described in the README, so you will need to find it in the documentation or the app settings.

Limitations: macOS Only, Core-Team PRs, and Thin Docs

The most obvious limitation is platform support. The README only mentions DMG downloads for macOS, so Windows and Linux users are out of luck unless they build from source, and even then the Electrobun shell may not support those platforms. Another limitation is the contribution model: the README states that only pull requests from the DeerFlow core team members are merged. This means external developers cannot contribute code directly, which may be a turn-off for a community-driven project. The documentation is also relatively thin: it lists a user guide, core concepts, compaction, sharing, generating projects, and a plugin development guide, but the README itself does not go into depth on how the evaluation metrics work or how the replay feature handles non-deterministic runs. If you need detailed documentation, you will have to dig into the docs directory.

Alternatives and the LangGraph Bridge

A direct alternative is to use LangGraph directly, without a desktop app. LangGraph is a framework for building stateful agents, and LLM Space can generate LangGraph agents from your threads. The difference is that LangGraph is a code-first framework where you write graph definitions in Python or JavaScript, while LLM Space is a visual, desktop-based environment for prototyping and inspection. If you already live in an IDE and prefer code-level control, LangGraph alone might suffice. Another alternative is a cloud-based agent evaluation platform, but the README does not name any. The key differentiator of LLM Space is its local-first, visual inspection and replay capabilities, which are not typically available in code-only workflows. If you value seeing every step and stepping through failures, LLM Space offers that in a way that a pure framework does not.

Maintenance and Upgrade Considerations

The project is actively maintained, with recent releases v4.15.2, v4.15.1, and v4.15.0 all pushed in late August 2026. The app updates itself in place, which reduces upgrade friction. However, the need for Bun and mise for source builds means that if you build from source, you must keep those tools updated. The monorepo layout with multiple packages suggests that changes to core or runtime could affect the desktop app, but the self-update mechanism should handle that for end users. The MIT license is permissive, but the contribution policy is restrictive, so if you plan to fork and maintain your own version, you are legally free to do so under MIT, but you will not get upstream merges. The README does not mention any migration guides for major versions, so upgrading across major versions (e.g., v3 to v4) may require manual steps.

Editorial conclusion

Adopt LLM Space 4 if you are an agent developer who wants a visual, local-first environment to prototype, trace, and debug harnesses, especially if you already work with DeerFlow or LangGraph. Skip it if you need a fully cloud-hosted solution or if you are not comfortable with a Bun-based monorepo and the associated tooling. Before adopting, verify that the current release supports your operating system (macOS editions are mentioned) and that your model providers and plugins are compatible. Also review TELEMETRY.md to understand what anonymous data is collected and how to opt out, and confirm that the contribution model (core-team-only PRs) does not block your workflow.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes