# Introduction

> What darting.dev is, the gap it fills, and where to start.

darting.dev is a command center for autonomous coding agents — launch many threads of work in parallel, each in its own isolated sandbox, with structured memory and zero context-management overhead.

It sits in the gap between three kinds of tools:

- **IDE-bound tools** are tied to your editor and a folder. They autocomplete, but they don't manage work — you still track what was requested versus what was built.
- **Chat-only tools** can discuss code but have no filesystem and no computer, so you copy-paste back and forth.
- **Cloud agents** have a computer, but it isn't _your_ computer, and the feedback loop is poor.

darting.dev gives you a chat interface backed by a real filesystem, autonomous background agents, and a memory system that eliminates the context-window problem.

## The core idea

You describe an outcome. A persistent **lead agent** turns it into work, and a **swarm** of agents executes it in parallel — each in its own isolated cloud sandbox, each on its own git branch. When the work is done, you review the diff and merge it or open a pull request.

```text
You ──▶ Lead agent ──▶ swarm of agents
                       ├─ explorer  (maps the codebase)
                       ├─ coder     (writes + runs tests)
                       └─ UI driver (records video proof)
```

The **Project Map** is your command center: shipped PRs, in-flight threads, and proposed plans across every product area — with one-click **Build** on plans that are ready.

## What makes it different

- **Parallelism by default.** An explorer can read code while a coder mutates it — they're coordinated inside the thread's sandbox, and separate threads never collide.
- **Memory that maintains itself.** A knowledge base captures architecture and decisions, an **Atlas** files every entry under a living map of your product's areas, and background agents keep both current.
- **Proof, not promises.** Implementation tasks produce a video of the feature working, recorded by an agent driving your app in a real browser.
- **A merge queue that respects your repo.** File-overlap grouping lands disjoint PRs in parallel; auto-merge only runs when you arm it.

## Where to start

1. Read the [Workflow](https://darting.dev/docs/workflow/) to see the end-to-end loop.
2. Take [the workspace tour](https://darting.dev/docs/workspace-tour/) to learn where everything lives.
3. Learn how [Isolated sandboxes](https://darting.dev/docs/isolated-sandboxes/) keep agents from stepping on each other.
4. Understand [Threads & branches](https://darting.dev/docs/threads-and-branches/) and [How the lead agent works](https://darting.dev/docs/lead-agent/).