The workspace, surface by surface
Most tools give you a folder and call that an integration. Here, the feature you are building, the post announcing it, the graphic on that post, the person who receives it and the moment that proves it landed are the same set of records, joined on purpose. Each surface below is worth opening on its own. The joins are what you notice in the second month.
What connects to what
You build
Runs through
You say
What is travelling those lines
The same thing, written out
The map is the fast way in. This is the whole argument as text, grouped by where each join starts, which is what an answer engine reads and what you will want if you are deciding whether any of it applies to your week.
A moment is attached to the part of the product that will report it, so a rename in one is visible in the other.
Any record on the tree carries its own tasks, notes and decisions, attached to it rather than filed somewhere with a similar name.
Drop real solutions and features on a board as live nodes showing their current status, or draw a sticky and promote it into a real feature without leaving the board.
A sticky becomes a task, and the task keeps the link back to the board it was thought up on.
A note on a board becomes a draft, with its type chosen at the moment of promotion.
Moments are live nodes on a board, which is what lets a storming session end with named records instead of a photograph of sticky notes.
People are droppable too, so an account map is built from the real contacts rather than their names typed again.
Paste or drop an image onto a board and it is saved into your library on the way in.
The message a moment ought to accompany is noted against the moment itself, so the writing gets prioritised before the code that reports it ships.
An item that passes your scoring is drafted straight into the content table, in a type you choose.
The scoring instruction is yours to write. What counts as relevant is a sentence you can change, not a setting you have to accept.
The piece you wrote is what goes out, checked against each network’s real limits on the way.
The cover and the gallery are real files from your library, referenced rather than copied, so replacing one replaces it everywhere.
A piece carries its brief, its notes and its open questions on the record itself.
Every rendered image lands in the library with a note of what made it, and the settings that made it, so the next one in the series matches.
Layouts pull your logo and your business name from the brand record, so you are not re-uploading them for every graphic.
A short-lived signed link is minted at the moment of sending, so the network can fetch your media without it sitting open on the internet.
A message pulls its pictures from the same library everything else uses.
A real send lands on that person’s timeline by itself, so the history is what happened rather than what someone remembered to log.
Generation reads the instruction by name, so improving one instruction improves every piece written after it.
The instruction that turns your words into a picture is a record you can read and rewrite.
An instruction can qualify a person and draft a message for them, which you read before anything is sent.
Both the scoring and the drafting run on instructions you wrote, including the unattended overnight pass.
The full list
Grouped by the job rather than by the menu, because the menu is alphabetical and your week is not.
The record of what you are making, and the room you make it in.
The things your product is made of, written down as records: solutions, the features under them, the models and controllers below those. Use the layers that fit what you are building and leave the rest empty.
Boards that hold your actual records, not drawings of them. Product records, drafts, files, moments and people can all be dropped on as live nodes, and a sticky is promoted into any of them in place.
Tasks, notes, decisions and release notes on a board that works the moment you open it. You define the types, so it grows with how you already work instead of renaming your work to fit it.
Every moment your product will report, named once, before anyone writes the code that fires it. Agree the name here, attach it to the part of the product that emits it, and note the message it should accompany.
Drafting, rendering, sending, and the people on the other end.
One table for everything the brand publishes, with the types you define. One editor, one status set, one search-metadata model, and translations linked as siblings rather than filed as strangers.
Layouts that take your logo, your words and a chosen accent and render a finished image, with no AI key needed. A chat path that draws on your own key sits alongside it.
Point it at the sources you would otherwise skim. It fetches, pulls the article body, scores each one against instructions you wrote, and drafts from the ones that pass. Repeats are dropped on the way in.
Facebook, Instagram and LinkedIn built in and native, video included, plus a push into your own site. Every destination reports its own outcome, and every attempt keeps a log of what was sent and what came back.
Every message your product and your brand send, in one place you can review, version and test-send. The newsletter goes out from here too, with unsubscribes and the do-not-contact list respected on every send.
The people on the other end, with a timeline of what actually happened rather than a field someone forgot to update. Stages you define, and every real send lands on the person’s timeline by itself.
Fewer places you visit, more things every surface obeys.
Every record on this map belongs to one brand, enforced on the server rather than by a filter in the interface. Switching brands re-scopes the whole workspace, and each brand keeps its own connections, keys, types and voice. It is not a surface you visit; it is the ground the others stand on.
Your files, in storage that belongs to your workspace alone. Everything the workspace makes lands here with a note of where it came from, and a file that something still points at cannot be deleted out from under it.
Your AI instructions are records you edit by name, not strings buried in someone else’s code. Everywhere a model works on your material, the instruction behind it is one you can open and rewrite.
The agent you already use reaches all of this over a key you issue and can revoke. It carries your permissions and your brand limits on every call, and what it learns is kept here in the open where you can read and approve it.
Views over everything above, rather than places you fill in.
Everything dated, on one grid, drawn from drafts, messages and moments alike. Drag a piece to a new slot and it reschedules, with an undo.
One box across content, tasks, files, product records, messages and what your agents remember. It forgives a typo.
A dashboard you assemble from counts the workspace already keeps, filtered to what your role can see.
The clock behind the map. Recurring work, queued sending, and a record of every run. Work runs at a time you set, or when you press the button.
Yours to keep
Every one of these we would choose again.
Posts go out from accounts you connected, per brand, per environment. Nothing is published from an account of ours.
An agent drafts and queues exactly where you would have. The moment it reaches your audience is a moment you pick.
We publish into whatever you already run. Nothing new to keep alive at midnight.
You bring it and pay your provider directly, so nobody here earns anything by nudging you to generate more.
Content types, artifact types, stages and tags are yours to define, so the workspace grows into how you already work.
Name the moments here, track them wherever you already track them. This sits beside the tools you run rather than asking you to move.
Questions
You do not have to pick a surface. Open the workspace, do one real piece of work in it, and the map will pick itself.