Dryvre

Dryvre brings documents, tasks, conversations, and AI output into one living block tree—so people set intent and agents can finish the work.

Comment

Inspiration

Modern work is split across documents, task trackers, chat, and AI tools. Briefs become tickets, decisions disappear into chat, and results rarely return to the original document. People and Agents repeatedly reconstruct the same context.

We asked: what if the document, plan, conversation, and AI output were never separate objects?

Our answer is one tree of first-class Markdown blocks. Views change, but information is never copied or converted. Everything is a block. Humans set intent; Agents close the loop.

What it does

Dryvre renders the same block tree in three ways:

  • Document presents context and knowledge as an editable hierarchy.
  • Board groups blocks with a status into To do, In progress, Blocked, and Done.
  • Stream keeps conversations and AI results directly below the block they discuss.

Switching views never creates a copy. Each block keeps its identity, Markdown, status, references, and children. References act as links, backlinks, and AI context.

Dryvre also implements a human-agent work loop. A PM Agent turns the current context into an editable task contract. It stays a draft until a person moves it to todo, explicitly approving execution.

The Developer Agent validates the contract first. Missing information moves the same task to blocked and sends a linked question to the user's Inbox. After the reply, the task resumes and reaches done only with recorded verification evidence.

Users can run Agent blocks through a local Codex CLI. Dryvre's MCP connection lets Codex update the canonical tree, while the direct AI composer uses the OpenAI Responses API with GPT-5.6 by default.

How we built it

Dryvre is a TypeScript monorepo with React and Vite, Fastify REST and WebSocket APIs, PostgreSQL with Drizzle, shared contracts, and an MCP server. All content changes use seven transactional operations, while block versions provide optimistic conflict detection.

Document, Board, and Stream project the same records. Markdown is the only body format; subtrees and references define visible AI context.

For local Agents, the server compiles Agent and Skill blocks into a managed Codex environment. Safe runtime events reach the UI, final responses become child blocks, and MCP tools use Dryvre's existing operation log and Agent identity.

The complete PM → approval → Inbox → Developer flow has a deterministic browser test using a real server, ephemeral PostgreSQL, WebSockets, and Chromium. We also maintain a real Codex MCP smoke path.

Challenges we ran into

Our first challenge was resisting extra entities. Separate models for projects, issues, messages, notifications, Agents, and Skills would recreate the fragmentation Dryvre is meant to solve. We repeatedly asked whether each feature could remain a block, tree relationship, or reference.

The second challenge was preserving one identity across three interfaces. Document edits, board moves, messages, and Agent results must update the same record. Transactional operations, optimistic versions, and one WebSocket connection gave us that consistency.

The local Codex runtime added practical challenges including MCP approvals, stale sessions, timeouts, cancellation, process cleanup, and event reconciliation.

Agent state also required precise semantics. blocked cannot mean a generic failure, and Inbox requests cannot duplicate. We separated task state from process state and required evidence before done.

Accomplishments that we're proud of

One canonical block can be edited as a document, moved as a board card, discussed as a stream, used as AI context, and completed by an Agent without changing identity.

We are especially proud of the PM → human approval → Developer loop. When a decision is missing, the system blocks the task, asks the right user, resumes after the reply, and completes only with evidence.

Agent and Skill definitions remain editable, reusable blocks instead of another administration silo. Unit, PostgreSQL integration, browser, deterministic demo, and real Codex MCP test paths support the vertical slice.

What we learned

We learned that better AI collaboration starts with the workspace, not simply more automation. When context, work, decisions, and results share one structure, Agents need less prompt assembly and people reconcile fewer copies.

We also learned that status can become a control boundary: todo is human authorization, in_progress is an Agent's claim, blocked requests human input, and done requires evidence.

Reliable Agent UX also depends on everything around the model call: visible context, deterministic transitions, recovery, and durable results. Streaming an answer is easy; making it accountable is the real challenge.

What's next for Dryvre

Next, we want to add production authentication, stronger tenant isolation, safer process boundaries, and robust multi-user synchronization.

For Agents, we plan to explore bidirectional Codex sessions, in-run approvals, isolated sandboxes, scheduling, and cost controls. New search, permissions, integrations, and workflows must still resolve to blocks, trees, and references—not parallel sources of truth.

Our goal is a workspace where people express intent, Agents act with context, blockers return to the right human, and results remain connected to their purpose.

Built With

Share this project:

Updates