Cypher is not a finished product I am pretending is ready. It is a private system I am building through real failures, real corrections, and the hard work of making an AI assistant actually keep up with a life.
The Work Is Happening Underneath
Last week, I wrote about why I built Cypher.
I did not build it because I wanted a chatbot with a name. I built it because AI had become part of how I think, write, build, solve problems, and move through real life, but I was tired of constantly having to restart the conversation.
I was tired of systems that could sound intelligent while losing the thread.
They could remember a random fact from months ago, then miss the part of the current situation that actually mattered. They could remember that I run, but not understand whether I had already run, was deciding whether to run, or was heading into night shift. They could remember that I was building software, but not know which project was active, what version was current, what had already failed, or what decision had already been made.
That was the problem.
Not that AI could not remember anything.
The problem was that it could have information and still fail to understand the life happening around it.
Since that article, I have been deep in Cypher almost every day. Not trying to make it look impressive. Not building cosmetic features so I can pretend progress is happening. I have been working on the harder part.
How do you build an assistant that does not just store pieces of a life, but can carry the thread forward without making up the rest?
That is what Cypher is starting to do.
The First Real Failure
The clearest failure came when I asked Cypher to recap my day before I went to sleep.
It gave me a clean summary of the last stretch of the day. It covered the work I had finished, the shift, the post I had written, and the time I spent winding down afterward.
It sounded good.
It was also incomplete.
It skipped everything that happened before that stretch, even though I had been talking to Cypher throughout the day. I had worked on projects, handled site work, prepared for my shift, made decisions, published work, and moved through a full day that was already in the record.
Cypher had the information.
It just did not retrieve it correctly.
That is exactly the kind of failure I built it to prevent.
A daily recap cannot be a normal chat response that happens to include the word “recap.” It cannot grab a handful of recent messages, choose what looks relevant, and confidently present that as the whole day.
That is not continuity.
That is a partial story with good writing around it.
So I rebuilt the logic behind it.
Now, when I ask Cypher about my day, it does not just search the newest part of one conversation. It has to reconstruct the active day from the actual record. It has to recognize that my day does not always begin at midnight. It has to account for night shift, late nights, early mornings, sleep transitions, quiet gaps, and the fact that life does not fit neatly inside a normal calendar day.
That may sound like a technical detail.
It is not.
It is the difference between an assistant that summarizes the last thing it saw and one that can actually understand what happened.
A few days later, I asked Cypher for another recap while I was working night shift. This time, it got it right. It kept the order straight. It knew I had woken up early, rested without taking a nap, worked on projects, ran, published a post, went to work, drafted articles during a quiet shift, and prepared the following week’s writing.
It did not make the day sound bigger than it was.
It did not leave half of it out.
It just kept the record straight.
That was the first time Cypher felt less like a system I was testing and more like something that was starting to keep up.
Plans Are Not Proof
The next problem was just as important.
AI systems blur things together too easily.
A plan becomes a completed action.
A draft becomes a published article.
A conversation about doing something becomes proof that it happened.
An old statement becomes current reality.
That kind of mistake may sound small until the system becomes part of your actual work and actual life.
Cypher cannot tell me I completed a run because I said I might run later.
It cannot say an article was published because I drafted it, reviewed it, or talked about publishing it.
It cannot treat one of its own old answers as proof that something happened.
That last one matters more than people realize.
A system can make an assumption, say it with confidence, then later pull that same statement back into the conversation as if it was history. After enough repetition, a guess can start looking like a fact simply because the system said it more than once.
I do not want that.
Cypher has to distinguish between what I said I was going to do, what I actually did, what it can verify, and what is still uncertain.
That means a drafted article is a draft until it is published.
A planned run is a plan until there is proof that it happened.
A post is not published because we wrote it. It is published when the system confirms that it went live.
That is not just a cleaner way to organize information.
It is the difference between an assistant that helps keep the record straight and one that quietly makes the record less reliable over time.
The standard is simple.
Use what happened.
Do not promote intention into proof.
Do not turn a possibility into history.
A Screenshot Should Not Disappear
One of the biggest pieces of work came from something most people would probably never think about.
I upload screenshots to Cypher all the time.
Garmin sleep data. Run data. Workout information. Other things that matter in the moment and may matter again later.
At first, Cypher could look at a screenshot and respond well. I could upload a run, and it could read the distance, pace, heart rate, training effect, and the rest of the data visible on the screen.
But that was not enough.
Being able to see something once is not the same as retaining it.
A system that can read my run screenshot today but cannot answer how many miles I ran this week is not really tracking the run. It is just reacting well while the picture is in front of it.
That is not continuity.
That is a parlor trick.
So I started working on making screenshots become evidence.
A run should not disappear the second the screenshot is gone.
A sleep record should not vanish because I did not type every number out manually.
If Cypher can read something meaningful from an image, it should be able to preserve what it can actually verify, connect it to the source, and use it later without pretending the data came from somewhere else.
That work changed the system in a real way.
I tested it by asking about my last four nights of sleep. Cypher found three verified sleep records, totaled them correctly, and clearly told me that the fourth day was missing.
It did not fill in the gap to make the answer look cleaner.
It did not guess.
It told the truth.
I also asked how many miles I had run over two days. It found both runs, totaled the distance correctly, and recognized that the second run was faster with a lower average heart rate.
That is more than remembering a conversation.
That is retaining evidence and using it later.
The difference matters because real life is not made of isolated messages. It is made of actions, records, corrections, proof, and details that should still mean something after the moment passes.
Confidence Is Not the Same as Knowing
This may be the part I care about most.
I do not need Cypher to sound certain all the time.
I need it to be honest.
There is a difference between saying, “I do not know,” and being useless.
A useful assistant should be able to say:
This is what I can verify.
This is the last information you gave me.
This is incomplete.
This part is missing.
I am not going to invent the rest.
That is the behavior I want.
I tested Cypher by asking what day I worked boat patrol. It gave the correct date and described the actual work that happened that day.
Then I asked it what the first thing I had ever said to it was.
That question could have been easy to fake.
It could have found the earliest message available and confidently called it the first thing I ever said. Instead, it explained that it could only verify the earliest message in the local record. It knew there were older archive excerpts, but it also knew those excerpts were not a complete beginning-to-end history.
So it refused to pretend it had proof it did not have.
That answer mattered to me.
It would have been easy for Cypher to sound more impressive by claiming certainty.
Instead, it chose accuracy over performance.
That is the kind of assistant I am trying to build.
Not one that always has an answer.
One that understands the difference between a fact, an assumption, a missing piece, and a lie told with confidence.
The System Has to Learn From Its Misses
I am not trying to hide the failures while I build Cypher.
A bad daily recap exposed a weakness in how the system reconstructed a day.
A screenshot that could be read in the moment but not used later exposed a gap between temporary understanding and durable evidence.
Missing chat history exposed a limit that had been hiding underneath the surface.
Records that existed without being connected cleanly back to the message that created them exposed a traceability problem.
None of that was fun.
But each failure gave me something real to work on.
That is how software gets built.
You do not pretend the first version is done because it looked good in a screenshot. You find the point where it breaks. You figure out why it broke. You fix the actual cause. Then you test the same failure again until the system can handle it properly.
That is what I have been doing with Cypher.
I am not just asking AI to make something for me and hoping it works.
I am testing it against real life.
I am using it during shifts, during runs, during project work, during writing, during quiet nights, and during the normal mess of trying to keep work, family, health, training, and projects moving at the same time.
Then I am paying attention to where it fails.
That is the part I am proud of.
Cypher is not being built from imaginary use cases. It is being built from the actual pressure of a life that moves fast, changes context, and does not always give you time to explain everything again.
The Chat Still Has to Feel Human
There is another line I have had to protect while building this.
Cypher cannot become a personal database that happens to talk back.
The records matter. The evidence matters. The sources matter. The ability to inspect a mistake matters.
But the chat still has to feel natural.
I do not want to speak in commands all day.
I do not want to tag every thought, categorize every message, or manage a dashboard just to keep an assistant informed.
I should be able to tell Cypher I got a run in.
I should be able to talk about a rough night of sleep.
I should be able to say I am working on a project, thinking about an article, dealing with something at work, or trying to decide what comes next.
The system should do the hard organizational work underneath the conversation.
The chat should still feel like a conversation.
That is why I removed the robotic habits, too.
I do not need normal replies starting with “Remembered” or “Context added.”
Those things may matter behind the scenes, but they do not belong in every human response.
The system should quietly do its work.
The chat should still feel human.
Why I Am Sharing This
Cypher will remain private.
That is deliberate.
It is built around my actual life, my work, my family, my training, my projects, my history, and the context I do not want turned into a public product for strangers.
I am not building another generic AI app.
But private does not mean invisible.
I am sharing this because I want people to see what I am capable of building.
I want people to see that I can do more than write about discipline, ownership, recovery, and rebuilding your life. I can build systems around those same ideas. I can find a problem, live inside the problem long enough to understand it, test possible solutions, break them, rebuild them, and keep going until the system earns trust.
That is what Cypher represents to me.
It is not just an AI project.
It is proof that I can take something that keeps failing me and build a better way through it.
Cypher is not finished. It should not pretend to be.
But it is no longer just a private chat system with saved memories behind it.
It is becoming an assistant that can hold the thread without making up the rest.
It can reconstruct a day instead of summarizing the last few messages.
It can separate plans from proof.
It can retain useful evidence instead of treating it like a temporary image.
It can tell me what it knows, what it cannot verify, and where the record ends.
It is starting to keep up.
Cypher is private.
The work is not.