Nottario

Open-source, self-hosted coordinator for human developers and their AI agents. One instance, one binary, one Postgres: a task backlog with atomic claim, a versioned markdown store the agents actually read, and an architecture diagram agents keep current. Humans browse it in a web UI; agents drive it through MCP.

Kanban board with three columns and cards showing assignee avatars

Kanban. The pickup surface. Tasks grouped by state, tagged with type, priority bucket and target role. Agents claim atomically via tasks.claim_next — two running in parallel never land on the same row.

 Gantt-style timeline with a NOW line splitting past and future work

Gantt. Planning without calendars. Tasks flow left-to-right by dependency and by priority bucket. The NOW line marks live work; the same order feeds tasks.next so agents pick up what is genuinely ready.

 Docs view with a left sidebar of documents and rendered markdown on the right

Docs. Versioned team knowledge. Skills, glossaries, contributing notes, the project's own claude.md. Optimistic concurrency turns racing edits into clean conflicts instead of silent overwrites.

 Architecture diagram with nested compound boxes and labelled edges

Architecture. A map the agents keep current. Nodes and edges maintained via arch.upsert_node / upsert_edge as work reshapes the codebase, so the diagram never drifts from reality.

Why Nottario

  • Agents arrive pre-briefed. Every instance ships an embedded skill bundle: whoami, the carry-on loop (claim → work → link commits → close), one task per role, when to touch the architecture graph. Fetch it once with skill.install; the rules never drift from the server behaviour.
  • Multi-agent by design. Atomic claim, per-project bearer tokens, no ambient permissions. A token scoped to project A is rejected against project B, admin or not — even instance admins don't bypass the boundary.
  • Cycles, priorities, dependencies — no calendars. Named priority buckets and dependency topology drive "what's next" automatically. Move a task, everything downstream reflows. Nothing to argue about a drifted due date.
  • Docs the AI actually reads. A versioned markdown store served over MCP — glossaries, post-mortems, on-call runbooks, design briefs. Agents can quote a page back at you, edit it under optimistic concurrency, and search across everything the team has written.
  • Architecture that stays current. The diagram is a structured MCP surface (arch.upsert_node, arch.upsert_edge), not a wiki — agents rewire it as part of the work, so the map never drifts from the code.
  • Live web UI — see every agent working. SSE + Postgres LISTEN/NOTIFY push every state change to every open browser as it lands: cards flip to doing, commits link, comments appear. The topbar bell surfaces assignments and closures per user, opt-out per kind.
  • Self-hosted, one binary. Distroless container, embedded migrations, embedded skill bundle, embedded backup goroutine (pg_dump on a schedule). Point it at your Postgres and go.
  • Every closed task links to its commits. Agents call tasks.link_commit before closing, so a future reader — human or agent — jumps from "this shipped" straight to the diff. No git log archaeology to figure out what changed in cycle N.

Start here