Why I built SharePlane

I was trying to solve a continuity problem.

I did not start by trying to build another publishing platform. I was trying to stop valuable thinking and work from becoming expensive to reconstruct every time attention moved, a session ended, a model changed, or an interface disappeared.

The upside is synthesis. The downside is state.
Read the story ↓About Tony at malott.ai ↗
ConversationDecisionArtifactEvidenceUnfinished thread
remembersearchre-explainreconcilerepeat
Governed WorkIdentityMeaning · evidence · relationships · authority · state · history · next action

I kept having to rebuild the same thinking

I've spent a good part of my life working on systems that have to keep functioning after the person who built them has gone home, moved on, or simply forgotten what they were thinking at two in the morning. You learn pretty quickly that a system isn't finished just because it works today. Someone needs to be able to understand it tomorrow, figure out what changed, and recover when something goes sideways. That has always made sense to me in engineering. Somehow, when the work moved into conversations and AI, I found myself violating the same principle.

My work tends to spread. An idea that starts in endpoint engineering turns into a question about security, then automation, then architecture, then something that has very little to do with where I began. I like that. It is often where the useful thinking happens. But it also means the context doesn't sit politely in one document waiting for me to come back. It gets scattered across conversations, code, diagrams, drafts, failed experiments, and decisions that made perfect sense at the time. Then I would return to something important and spend half the session figuring out where the hell I left off.

The files were usually still there. So were the chat histories, the commits, and the artifacts. What was missing was the part that made them useful together. Why had I chosen one approach and rejected another? Which evidence had actually held up? Was that beautiful-looking version accepted, or was it the one we had already decided never to use again? What was the next valid action? I could recover individual pieces, but reconstructing the reasoning between them became its own project. And when the reconstruction was done by a model, I had to check whether it was remembering history or just telling a convincing story about it.

I didn't want to spend my time being the human glue between systems that were supposedly making me more productive. That became the irritation I couldn't leave alone.

AI made the problem impossible to ignore

Before these systems got so capable, there was a natural speed limit on how much I could start. You can only write so much software, examine so many architectures, or pursue so many ideas in a day. AI changed that dramatically. I could follow a thought into a working prototype, test an assumption, challenge the result, and go somewhere else while another piece of work was still moving. It was freaking remarkable, and I still think we're underestimating what happens when that kind of capability becomes ordinary.

But more intelligence didn't automatically give me more continuity. Quite the opposite. I had more parallel work, more context worth keeping, and more places where a seemingly small mistake could send an entire thread in the wrong direction. A session might produce an excellent result and leave behind almost no dependable way for the next worker to pick it up. The next model could be smarter and still lack the evidence behind the last decision. It could even sound certain about something we had explicitly rejected. I was getting faster at creating value and, in some cases, just as fast at losing the thread that made the value usable.

At first I went after the obvious target: memory. Preserve the conversation. Save the context. Reconstruct the agent. Make the next session feel like the same mind returning to the desk. I experimented with different forms of persistence because the instinct seemed right. Some of it helped. I could recover more. I could reduce repetition. But the more I pushed, the more I saw the flaw in treating the assistant's apparent continuity as the thing I was trying to protect.

A model can reconstruct a plausible explanation without possessing the authority to say what happened. Memory can be stale, partial, or simply wrong. And I don't actually need the same agent, the same model, or even the same machine when I come back. I need the next participant to start from an accurate account of the work. That distinction turned out to be much bigger than I expected.

The work had to outlive the worker

Once that clicked, I began asking a different question. What would have to exist so that I, another person, or another agent could return to this piece of work without making up the missing history? The answer wasn't an infinitely long transcript or a magic memory file. I needed something with a stable identity, a record of what it meant, the evidence supporting it, the decisions that governed it, and enough of its history to understand why it looked the way it did.

I started thinking of the work itself as the durable unit. An essay, a design, a piece of software, an investigation, or a prototype could have very different forms, but the responsibility around it was familiar. You should know which version you're looking at, who has authority over it, what was actually accepted, where the supporting material lives, and what remains unresolved. A useful handoff should say what to do next without pretending every earlier question is settled. If a prior route failed, that failure should be part of the inheritance. Otherwise we are just paying to relearn it with a newer model.

This is where my engineering background kept pulling me back to basics. We already know how to preserve versions, verify artifacts, enforce permissions, and keep receipts. We know how to separate something that was tested from something that was actually released. Yet we routinely let highly capable assistants blur those distinctions because their explanations sound coherent. I don't want to govern every keystroke an agent makes. I want to be precise about what it has the authority to change, and then give it room to do useful work inside that boundary.

The principle I've kept coming back to is simple: probabilistic semantics, deterministic authority. Let intelligence explore, reason, challenge, and build. Don't let it invent the history, the acceptance, or the permission to publish. That isn't a constraint on thinking. It is how the results become worth keeping.

So why build a public place for it?

That question took me to SharePlane. I wanted somewhere my developed work could live without being reduced to a pretty page at the end of a workflow. I love a good reading experience. I care about visual design, and I don't think technical material has to look like a compliance binder to be credible. But I also wanted the reader to be able to follow the thinking when it mattered: inspect the evidence, see related work, understand the limits of a claim, and reach the underlying artifact rather than being asked to take my word for it.

I also didn't want every idea forced into the same container. Sometimes the right thing is an essay. Sometimes it is a diagram, an interactive tool, a prototype, a complete application, or a package someone can examine offline. The form should serve the work. I've spent enough time watching systems flatten interesting things into generic templates because that was convenient for the publishing machinery. If I built another one of those, I would have missed my own point.

That's why the public surface matters to me, but the page is only part of it. The real work needs to survive behind the page, with enough identity and provenance to remain understandable as tools, interfaces, and delivery methods change. Someone should be able to read the argument without signing into my development environment. A curious reader should be able to go deeper without needing access to my private repositories. And a machine should be able to inspect the authorized public context without guessing what a rendered paragraph means.

We have already run into the sort of stupid little problems that prove why this matters. A library and its search interface can disagree about how many public works actually exist. A footer can advertise a relationship that doesn't lead anywhere. A newly published article can accidentally inherit an older shell we thought we had retired. These sound like presentation defects, and they are, but they're also failures to carry one accepted truth consistently through the system. The answer isn't to add another dashboard. It's to make the authority and the projection agree, and to make disagreement visible before it becomes the public experience.

The publishing machinery taught me a few things too

I had to learn something uncomfortable while building this. In the beginning I tried to control too much of the process. Every edit felt like it needed another gate. Every agent needed a tighter leash. That seemed responsible until the friction started costing more than the risk it was supposed to manage. I was spending an absurd amount of energy moving work through the system I had built to help move work through the system. There's a certain engineering comedy in that, though it wasn't particularly funny while I was debugging it.

Then I started separating the controls that actually protect something from the rituals that merely slow it down. Give a worker the tools and enough freedom to repair a bounded problem. Let it test and iterate. But require clear authority at the points that matter: claiming ownership of a change, altering accepted meaning, touching production, or saying a result is complete. If a release fails, leave an intelligible receipt. If an old path keeps causing trouble, retire it for new work instead of trusting everyone to remember not to use it. I'm interested in systems that learn from the scar tissue, not ones that ceremonially collect it.

SharePlane has been a useful test of that belief because it has made the failures embarrassingly concrete. A successful build isn't the same as an accepted reader. An accepted reader isn't the same as a public deployment. A page returning HTTP 200 isn't proof that the page you intended is there. Those sound like obvious distinctions, and they are, right up until an automation pipeline quietly collapses them. I want the system to keep those boundaries honest so the human doesn't have to spend every morning policing the same mistakes.

Where GhostMesh fits

As SharePlane developed, another layer became clearer. Preserving the work is one problem. Coordinating all the temporary intelligence acting around it is another. That larger problem is what I'm working through with GhostMesh: how agents discover context, obtain capabilities, act within authority, leave evidence, recover from failure, and hand work to the next participant without making the operator reconstruct every transition.

I don't want this tied to one model, one vendor, one operating system, or whatever interface happens to be fashionable this month. I have used enough platforms to know how quickly a supposedly permanent center of gravity can move. The workers will change. The hardware will change. The conversations will move. What I want to keep stable is the work and the accountability around it. SharePlane gives developed public work a durable home. GhostMesh is the operating architecture that can help work keep moving across tools and agents. They're connected, but they aren't the same product, and they shouldn't be confused just because they grew out of the same frustration.

There is an important human boundary in all of this. I use AI heavily. It helps me examine assumptions, develop arguments, build systems, and catch errors, including errors of my own making. Some of what we produce is the result of substantial collaboration with machines. I'm not interested in pretending otherwise. I'm also not willing to let a model's fluent explanation stand in for an author's judgment or a verified result. The public thesis is mine to accept, revise, or reject. The system ought to make that responsibility easier to see, not harder.

What I hope survives

I didn't set out with a grand plan to build a publishing platform, much less an architecture for an expanding workforce of agents. I was chasing a problem that kept showing up in different forms. Every time a session ended, a tool changed, or another piece of work took priority, I could feel the cost of getting back to a genuinely useful place. I wanted that cost to fall, even as the work became more ambitious.

I still expect to change my mind. Some designs we like today will look clumsy later. Some assumptions will fail. A few decisions will turn out to have been ridiculous, and I hope we can tell exactly why. That's part of the point. A body of work worth preserving ought to contain the corrections as well as the conclusions. It should be possible to follow how the thinking evolved without rewriting the past to make the present look inevitable.

If SharePlane does what I want, the next serious idea won't have to start with an archaeological expedition through my own tools. I can open the work, see what was actually decided, follow the evidence, and move forward. Another person can do the same without needing to borrow my memory. And another agent can contribute without pretending to be the one that came before it.

That's a better use of intelligence than repeatedly reconstructing yesterday. It's also, in the end, why I built SharePlane.

Semantic Work

Owner-accepted first-person thesis, with the original illustrated hero retained. The historical source remains separately inspectable. No Work-to-Work relationships have been invented.

Semantic Work payload ↗

Inspect the source

Original V2 HTML and source package are preserved byte for byte; the revised first-person thesis was accepted by Tony on October 9, 2026.

Original standalone page ↗ · Source register · Evidence

KEEP FOLLOWING THE THOUGHT

The article ends.
The connections do not.

Start with the reason this exists. Explore the Work, the evidence and the architecture around it.

←   Go to Library

Explore SharePlane

Connected thinking 4 approved relationships

View graph →
  1. I Was Summoning Ghosts Until I Learned to Build the MachineCompanion · The personal experiments behind the architectureRead published article ↗
  2. The Enterprise Has No MemoryCompanion · Continuity at enterprise scaleRead published article ↗
  3. The Semantic Operating SystemFoundation · The semantic foundation for durable WorkRead published article ↗
  4. What SharePlane IsContinue reading · Continue into what SharePlane isRead published article ↗

Open each connection to read the existing published article on SharePlane. Reader designs may differ; no Work was rewritten. Inspect the relationship evidence →.

Loading the public Work library…

Looking for something else? Search the SharePlane Library.