Explore fifteen workflows for individual projects, team handoffs and coding agents. Connect tasks to the bigger plan, see who is working on each branch, and preserve context for the next session.
A flat list is where a big thing goes to become invisible. These are the cases where the shape does the remembering.
A long write-up is a tree pretending to be a list. Chapters branch into sections, sections into the paragraph you have been avoiding for a week. Written flat, the avoidance is invisible; written as a tree, the ring on that chapter simply refuses to fill.
The shape: One project, a branch per chapter, leaves for the sections. Derived progress means you never mark a chapter done — it becomes done when its sections are.
Half of moving is admin nobody warned you about: searches, surveys, redirecting post, telling the council. It arrives in no order and each item spawns two more.
The shape: Add tasks as they turn up and drag them under the right limb later. Due dates on the ones with deadlines, and Gantt when you need to see what has to happen this week.
The cost of an occasional project is re-reading your own mind every time you come back. A tree holds the shape so you do not have to.
The shape: Hide completed, so Sunday opens on what is left rather than on what you already did. Snap the limbs together and the whole thing fits on one screen.
Syllabus in, revision out. The exam board publishes a hierarchy already; you are just filling it in.
The shape: Import the syllabus as main tasks, break each into what you actually need to revise, and let the percentage tell you where you are weak instead of guessing.
Everything in your head, in any order, as fast as you can type it — then shape it afterwards. Sorting while capturing is what stops people capturing.
The shape: Type into the add bar without thinking about structure, then drag the pile into limbs. Re-ordering on the map is a drag; nothing has to be right first time.
Delegation in LatticeRun is structural: a limb becomes someone else's project, and its progress still counts towards yours.
Three groups who need to see their own work and one person who needs to see all of it. The usual answer is three boards and a weekly meeting to reconcile them.
The shape: One tree, one limb per discipline. Everyone works their branch; the top-level ring is the launch, and it is honest because nobody types it in.
A contractor should see their piece and nothing else — not your other clients, not your internal roadmap.
The shape: Spin the branch into its own linked project and share that. They see their limb; progress still flows back into your parent tree, and the shell node in the parent tree keeps counting.
A sprint in another tool usually means re-entering work that already exists somewhere as a plan.
The shape: Name a Sprint, give it a goal, and pull tasks into it from any branch of the project. The tree stays the source; the sprint is a lens on it.
The risk in a handover is not the work, it is the context — what was tried, what was decided, what is still open.
The shape: Assign the branch, and the notes and activity travel with it. Whoever picks it up reads what happened rather than asking.
First-week checklists rot because they live in a document nobody owns.
The shape: Keep the onboarding tree as a template project, export it and import a fresh copy per starter, and watch the ring fill instead of chasing.
The agent claims a branch before touching it and reports what it built. If you choose to plan, the Project Plan stays where you can see it; a run leaves an account of itself.
A founder, an agent, or both can draw and edit a Project Plan. Plan Mode is optional; approval and release create or link executable tasks, and progress rolls back up through the tree.
The shape: One visual objective with phases, decisions, risks and executable work items linked to the canonical task tree.
Durable decisions, guardrails, architecture, checkpoints and handoffs stay with the project, with trust labels that make proposed, approved and verified context legible to successors.
The shape: A project-scoped record of durable context, plus a compact claim-time briefing for each successor.
This is the one LatticeRun was really built for. Point an agent at a project — or add it as a collaborator — and stop instructing it per task. You add work to the board as you think of it; the agent claims the next item, uses Plan Mode when requested, does it, and reports back. The list doubles as the agent's standing stream of instructions, so there is no second channel to keep in sync and nothing to re-explain each session.
The shape: One long-lived project. You write tasks; the agent claims, works and reports against each, using Plan Mode only when requested. The claim workflow is checked server-side; Strict refuses writes outside the claimed branch; planning remains optional, so an agent can work without a Project Plan when that is what you choose.
File defects the moment you hit them, in whatever words you have at that second. Triage later, or not at all.
The shape: Each defect is a task with a note. The agent takes them in order, and closes each with a sentence on what the fix was — so the log is also the changelog.
Ideas arrive constantly and most of them are worth writing down and not doing yet.
The shape: One intake limb. Anything you want built moves out of it into a real branch; the rest sits there costing nothing, visible, and not blocking.
The agent works while you do not. The question the next morning is what changed and whether you agree with it.
The shape: A scheduled run claims from the board and reports into it. You read the tree over coffee — the account of the work is the work's own record, not a terminal you have to scroll back through.
The risk with an agent is not that it works too slowly, it is that it confidently builds the wrong subtree.
The shape: Hand it a goal, have it plan the breakdown into the tree, and approve or redirect before a line is written. The plan is a thing you can argue with.
