Marq: run coding agents in parallel, and keep everything as Markdown

I'm building Marq, a desktop app that is a Markdown knowledge base and an IDE for coding agents at the same time. It's still early, and I'd like to hear what people think.

Features, file formats and keybindings may change without notice. I develop on macOS. Linux and Windows build, but I haven't tested them.

Why I made it

Running several coding agents at once is easy. Finding out later what each of them did is harder. Prompts, transcripts and results end up spread over terminals and chat histories.

In Marq, all of that is a plain Markdown file in your vault, next to your notes: requests, session logs, results, boards and crews. You can open them in any editor, grep them, or query them with mq, a jq-like language for Markdown that I also maintain.

Queue work and run agents in parallel

Requests wait in an inbox. They start one after another, or several at once if you allow it. Each task gets its own git worktree and branch, so agents working on the same repository don't overwrite each other's files.

Review in the app

The Changes panel shows the diff against the base commit. You can comment on diff lines and send the review back to the agent. When you're happy, commit, push and open a PR from the same place. When a session finishes, its result is written back into the request note.

Kanban boards

I wanted a board to plan work on, but I didn't want another tool with its own database. A board in Marq is a Markdown note. Each ## heading is a list and each checklist item is a card:

## Todo  - [ ] **T1** Write docs — @me - start with the README ## Done  - [x] **T2** Add logo 

Editing the Markdown edits the board. If you move an item under another heading, the card moves. If you move it under Done, it gets checked. The board tab shows the same file as columns, and you drag cards between them.

The board is also where work starts. Open a card and you can:

• Start a session with the card as the prompt. It includes the card's text and linked notes, and the agent is told where the card lives so it can update it with board_update_card. The card moves to Doing when the session starts.
• Queue the card in the inbox, and it runs when there's room.

Agents can read and change boards too. Marq also has a spec workflow: an agent writes a spec, and Break down turns each open item into a card that links back to the spec.

Crews

Several sessions can work on one project as a team, split by role (lead, implementer, reviewer and so on). The lead sets up the team, you approve each member, and they talk to each other by role and share a task list. That task list is a board, so it's the same Markdown as above.

Crews have guardrails. A hop limit stops members from messaging each other forever, and a message over the limit is held until you let it through. A route can forward a member's final reply to someone else automatically, for example every implementation result to the reviewer.

Not only Claude

Claude Code is the main agent, and it's the one that supports everything. Marq can also run a task on other agents:

• Codex, through its own app-server (codex app-server), so no adapter is needed. The New task dialog has a model and reasoning effort field for it.
• Gemini CLI, OpenCode, Qwen Code and Goose, through ACP (Agent Client Protocol). You can add any other ACP agent in Settings.
• Ollama, to run Claude Code against a local model.

You install and log in to these agents yourself, and Marq launches them with the command it finds in your login shell. The vault tools reach them over MCP, and their permission requests show up as the same approval cards. Each task still gets its own worktree, and the session is saved as Markdown like any other.

They come with limits. Crews and the sandbox are Claude only. You can pick Codex's model in the New task dialog, but the other ACP agents don't get a model picker and run on whatever model they're configured with. Other agents also work as a run in a comparison, so you can give the same task to Claude and Codex and keep the diff you prefer.

Markdown in, Markdown out

A request is just a note. Its body is the prompt, and context: attaches pieces of other notes picked with mq:

--- type: request status: todo project: ~/dev/git/mq context: - query: 'import "section" | nodes | section::find("Design") | section::body()' from: notes/design.md --- # Show types on hover  Implement what the design note says. 

Sessions are Markdown as well, so you can query your agents' history:

# Learnings from every session mq -A 'import "section" | section::find("Learnings") | section::body()' sessions/*.md # Every command the agent ran mq 'select(.code.lang == "tool:Bash") | .code.value' sessions/*.md 

Other things in there

• Compare 2 to 4 runs of the same task (Claude models, Codex and others) side by side
• Checks that run after each turn, with failures sent back to the agent
• Approval cards for tool calls, and resume for interrupted sessions
• Notifications when a session finishes, fails or needs approval
• Built with Rust and Tauri

Try it

git clone https://github.com/harehare/marq cd marq pnpm install pnpm tauri dev 

You need Rust, Node.js, pnpm and a logged-in claude CLI. Open any folder of Markdown files as the vault. Then hover a heading and choose Ask, or press ⌘N for a new task.

I'm still working out which parts are useful and which aren't. If something breaks or is missing, please open an issue or leave a comment.

Repo: https://github.com/harehare/marq