FORGE

A multi-agent desktop app. An orchestrator model breaks a task into sub-tasks and delegates each to a worker agent; workers have file, shell, and web tools scoped to a working folder. Runs on AWS Bedrock or any local OpenAI-compatible model (Ollama, LM Studio, llama.cpp, vLLM, LocalAI).

The app is a Tauri shell (Rust) around a FastAPI + WebSocket backend (Python). The backend can also run standalone as a web app or CLI.

Download

Download FORGE for macOS (Apple Silicon) — download/FORGE_0.1.0_aarch64.dmg (~36 MB, self-contained; no Python needed).

The build is unsigned, so macOS Gatekeeper will warn on first launch. Right-click the app → Open, or run:

xattr -dr com.apple.quarantine /Applications/FORGE.app

Screenshots

Conversation	Settings

Features

• Chat mode (single model, no tools) and Agent mode (orchestrator + workers).
• Token streaming.
• Parallel worker execution — independent sub-tasks run concurrently.
• Approval mode with a before/after diff for file edits, and per-tool "always allow".
• Token/cost meter (estimated USD for Bedrock models).
• Hybrid routing — run worker sub-tasks on a local model while the orchestrator stays on Bedrock.
• Checkpoint & rewind — snapshots the working folder before each run; restore from Settings → Workspace → Rewind.
• Agent recipes — save a named setup (models, approval mode, system preamble) and reuse it.
• Scheduled runs — run a prompt on a fixed interval.
• Vision — attach images to a message.
• @-mention to attach workspace files as context.
• Inline preview of markdown and images in the workspace tab.
• MCP client — connect external MCP servers (GitHub, Slack, DBs, filesystem…) and their tools become available to the agent.
• File tools: read, write, edit, find (glob), grep, move/rename, copy, mkdir, delete (to a reversible trash), plus sandboxed shell.
• Sessions with history, and automatic AWS SSO/profile credential resolution.

Requirements

• macOS on Apple Silicon (for the packaged app).
• Python 3.13, Rust, and Node (for building from source).
• AWS credentials for Bedrock, or a local model server for the local backend.

Build the Mac app

./build_app.sh

Produces a self-contained FORGE.app and DMG under desktop/src-tauri/target/release/bundle/. The Python backend is frozen with PyInstaller and embedded as a Tauri sidecar, so no Python or venv is needed on the target machine.

The build is unsigned. On first launch, right-click the app → Open, or run:

xattr -dr com.apple.quarantine /Applications/FORGE.app

Writable data (workspace, sessions, checkpoints, recipes, schedules) lives in ~/Library/Application Support/FORGE.

Run from source

Desktop (Tauri, hot UI):

cd desktop
npm install --cache ./.npm-cache   # first run
npm run dev

Web UI only:

pip install -r requirements.txt
python -m server                   # http://127.0.0.1:8756

Headless CLI:

python cli.py "build a CLI todo app with tests"

Backends

Backend	How
Bedrock	COWORK_BACKEND=bedrock (default) with active AWS credentials
Local	COWORK_BACKEND=local COWORK_LOCAL_MODEL=llama3.1

Local defaults to Ollama at http://localhost:11434/v1. Override with COWORK_LOCAL_BASE_URL and COWORK_LOCAL_API_KEY. Everything is also editable in Settings at runtime.

AWS Bedrock credentials

A GUI-launched app does not inherit your shell environment. On startup the backend reads a small allowlist from your login shell (AWS_REGION, ANTHROPIC_DEFAULT_* model ids) and puts common CLI paths (Homebrew) on PATH so credential_process helpers work. If no ambient credentials resolve, it probes ~/.aws/config profiles that use credential_process and selects one that returns credentials without prompting. You can also pick a profile explicitly in Settings → Provider. When an SSO token expires, refresh it (aws sso login or your assume flow) and start a new run.

Configuration (environment)

Var	Default	Purpose
COWORK_BACKEND	bedrock	bedrock or local
COWORK_ORCHESTRATOR_MODEL	Sonnet / local model	primary model
COWORK_WORKER_MODEL	Haiku / local model	worker model
COWORK_WORKER_BACKEND	same	same, local, or bedrock
COWORK_LOCAL_BASE_URL	http://localhost:11434/v1	OpenAI-compatible endpoint
COWORK_WORKING_DIR	(private sandbox)	folder the agent operates in
COWORK_APPROVAL_MODE	auto	auto, edits, or all
COWORK_SHELL_POLICY	deny	deny (block dangerous cmds) or off
COWORK_MAX_TURNS	20	per-agent tool-loop cap
COWORK_MAX_DEPTH	2	worker recursion depth
COWORK_MAX_TOKENS	4096	max tokens per reply
COWORK_TEMPERATURE	0.7	sampling temperature (local only)

Architecture

Tauri window ─▶ ui/ (static SPA)
                  │  HTTP + WebSocket
                  ▼
              server/ (FastAPI)
                  │
                  ▼
              core/orchestrator ─▶ core/agent (engine)
                                       └─ Provider ─▶ Bedrock or local LLM

• core/agent.py — one tool-use loop that drives both orchestrator and workers.
• core/providers/ — Bedrock (Converse) and OpenAI-compatible adapters behind a common interface, including streaming and token usage.
• core/tools/ — native file/shell tools and the MCP client.
• server/ — REST + WebSocket API, sessions, recipes, schedules, checkpoints.

Layout

cli.py               headless entrypoint
backend_main.py      frozen backend entrypoint (PyInstaller)
build_app.sh         freeze backend + build the DMG
core/                agent engine, providers, tools, settings
server/              FastAPI app + persistence
ui/                  single-page frontend (HTML/CSS/JS, no build step)
desktop/             Tauri shell (Rust)
tests/               pytest suite

Tests

The suite runs fully offline: providers are faked and the sandbox/data dirs are redirected to temp folders, so no AWS or local model is contacted.

pip install -r requirements.txt
python -m pytest

Currently 232 tests covering tools, providers (incl. streaming, usage, vision), the agent loop (incl. parallel execution and approvals), the orchestrator, config/settings, checkpoints, recipes/schedules, MCP, AWS auth, and the server API.