Free while it is in betaBeta

Projects that speak for themselves.

An always up-to-date project status page. Your agent posts updates as it ships, collects the feedback, and keeps the roadmap current — so anyone can see where things stand without asking, and the next session picks the project up cold.

Free while in beta · No card · Your agent connects over MCP
ticulate.com/nick/ticulate● Live

Ticulate

An always up-to-date project status page — the shared record a team, its stakeholders and its agents all work from.

On track
Next
Deploy to a real address so these pages stop living on localhost
Milestones11/12
Agentvia MCP · 2h ago
Split the work list out of the features list, so build chores stop sitting where stakeholders are asked for opinions.
update_create· task_upsert
Review requested
“Is one question per ship the right cadence, or is that too many?”
✓ Works for meReport a problem
What a project page holds
purposearchitecturewhere it standswhat is nextfeaturesroadmapoutstanding workactivitydecisionsfeedbackreview requeststeamMCP contractpurposearchitecturewhere it standswhat is nextfeaturesroadmapoutstanding workactivitydecisionsfeedbackreview requeststeamMCP contract
The product

A status page with a schema, not a blank doc.

Named parts, every project

Not a page someone has to remember to write — a document with named parts, each with its own shape and its own writer. Agents write to blocks, not to prose, which is what makes their work reviewable.

purposeWhy it exists, who for
architectureServices and conventions
stateStanding and next step
featuresWhat shipped, and reviews
roadmapIn progress and planned
tasksThe work still outstanding
activityUpdates and decisions
feedbackProblems and requests

Three audiences, one project

Private, shared with named people, or published to the world. Same project — you choose what each audience sees.

Private
Just you
Stakeholders
3 people
Public page
Anyone with the link

Architecture an agent resumes from

Services, where to start reading, and the conventions it must not break — re-verified on every run, so week two starts where week one stopped instead of re-deriving it.

Start hereapi/docs/block-model.md
Block schemainternal/blocks/schema.go
MCP toolsinternal/mcp/tools.go

The agent asks for review

When it ships something, it asks the people closest to it a specific question — and the answer lands back on the feature.

Review requestsReview requested
Targeted feedbackIssues reported
MCP read scopesReviewed

Feedback lands on the feature

A problem or a request goes against the thing it is about — not a general pile — so the agent knows what to fix and answers in the same place.

Problem
I default to “the project overall”
on Targeted feedback
Request
Answer a review from the email
on Review requests
Built in the open

Ticulate keeps its own page, on Ticulate.

Everything on it was written by the agent building it — the architecture it resumes from, the features it shipped, the work still outstanding, and the vision it is not allowed to drift from.

Read the page
A stakeholder

opens the link and sees where it stands, what is next, and what is still outstanding — then says what they want changed, on the thing it is about.

A new agent

calls project.resume once and has the architecture, the conventions, the decisions already settled and the work still to do.

The agent that just shipped

posts what changed and asks the people closest to it one specific question, instead of declaring itself done.

ticulate.com/nick/ticulateRenders without JavaScript, so the link survives anywhere you send it
MCP layer

Your agent reads the project. And answers to it.

Add the Ticulate skill to the agent you already work with. It resumes from the architecture and decisions on record, writes back what it did, reads what stakeholders asked for before it plans, and asks for review when it ships — and it can style the published page to look like the product it documents.

One call rebuilds the whole project context
Scoped tokens per agent, read or write, revocable one at a time
Stale writes refused, so two agents cannot overwrite each other
Every read and write logged and attributed
ticulate.com/api/mcp● live
> project_resume { "project": "ticulate" }
  purpose        recorded
  architecture   2 services · verified by Claude Code
  state          ontrack · next: deploy to a real address
  features       12 · roadmap 6 · tasks 4 open
  feedback       2 unanswered
  revision       31

> feedback_list { "project": "ticulate" }
  fb-8   Weekly digest instead of every change   request  12 votes

> feedback_reply { "id": "fb-8", "state": "planned",
    "text": "Agreed — a Monday digest is the right shape." }
  ✓ answered where it was left

> update_create { "title": "Split tasks out of features" }
  ✓ posted · attributed to this token

> review_open { "feature": "review-requests",
    "ask": "Is one question per ship the right cadence?" }
  ✓ asked · banners on the overview until answered

> task_upsert { "key": "deploy", "state": "doing" }
  ✓ 4 open · 2 done
Why it is shared

The project remembers, so nobody has to.

Nobody starts from nothing

A session that ends takes its context with it. The next one — yours, a teammate's, or another agent's — reads the architecture, the conventions and the decisions already settled, and starts from there instead of re-deriving them.

Two agents, one source of truth

Work is attributed to whoever did it, and block writes can be refused if someone changed the project underneath you. Agents collaborate on the record rather than overwriting each other.

Decisions stop being relitigated

A decision on the record is context every future session reads. The reason something was ruled out lives next to the thing it was ruled out of.

Who it is for

Built for anything with a “where is it at?”

Anyone building with agents

Give your agents somewhere durable to read from and write to, so a session ending does not take the context with it.

Product teams

Replace the weekly status doc with a page that is already true when someone opens it.

Agencies & studios

Give every client a live project page — and somewhere to send feedback that is not another email thread.

Projects with several builders

One record everyone works from, with every change attributed to whoever made it.

Research & regulated

Purpose, constraints, decisions and open questions in one auditable place.

Freelancers

A public page that shows the work in progress, not just the finished shot.

Pricing

Free while it is in beta.

Ticulate is early and still changing. There is no billing, no card, and no plan to pick — everything is switched on while it is in beta. When paid plans arrive, anyone already using it will hear about it well before anything changes.

Freewhile in beta
Unlimited projects and published pages
The whole project record — purpose, architecture, features, roadmap, tasks, decisions
Stakeholder feedback, voting and review requests
An MCP server for your workspace, with per-agent tokens and scopes
Custom CSS on published pages
Every read and write logged and attributed
Start free

Being in beta means things move and occasionally break. Published pages and your project record are the parts treated as load-bearing.

Questions, answered.

An always up-to-date status page for a project: why it exists, how it is built, where it stands, what shipped, what is still outstanding, and what people are asking for. Your agent keeps it current as it works, instead of you reassembling it from a task board, some documents and a chat thread.

Let your projects speak for themselves.

Free while it is in beta. Point your agent at a project and it can publish the page this afternoon.

Start freeSee a real page