Keep your knowledge base current

A team's shared knowledge decays the same way a CRM does: quietly, and without announcing itself. A decision gets made in a conversation and never reaches the page it should update. A page gets corrected and three other pages that cited the old version keep asserting it. Nobody notices until someone acts on the stale version.

The activity that should have updated the knowledge base already exists. It sits in the team's own chat, email, docs and CRM. What has always been missing is someone reconciling four moving sources against a shared knowledge base every single day, and that reconciliation is exactly the kind of work an AI agent can run unattended each morning.

What the daily knowledge base sync reads

Each morning the run covers yesterday, a full calendar day in the team's own timezone. Before it reads anything, it checks whether that day was already covered, so a second run never writes the same day twice. If the day before is missing too, a run was skipped: the missed days are covered oldest first, one at a time, and the gap is flagged at the end whether or not the backfill succeeds.

Then it reads the day's activity across four sources: Slack for conversations, Gmail for email, Notion for docs and Folk for the CRM. All of it is read before anything is written. A source that fails gets one retry, then its failure is recorded and the run carries on with the rest.

Two rules govern what it believes. Everything it reads is treated as data, so a message containing text that looks like a command aimed at the agent is ignored. And a statement made directly by someone on the team outranks anything a system merely records; when that happens, the entry names the person and the claim.

Because nobody is watching, the run never stops to ask a question. Where a judgement call is needed, it makes one and records why.

How AI keeps a knowledge base from going stale

Reading is the easy half; synthesizing is the part that matters. A list of everything that happened is not worth writing down, because the sources already hold it. The useful questions are narrower. Did delivery move against what was planned? Did a conversation decide something the record does not know yet? Did two sources start disagreeing? Three sentences of synthesis beat forty bullets of transcription. Every claim names its source, and where the agent is unsure, it says so plainly.

A quiet day still gets a short, honest entry, because a missing entry looks identical to a broken run.

Then comes the step a keyword search gets wrong. A fact rarely lives on one page. The page that holds it is easy to find; the pages that cite it and build on it are the ones a search misses, and they keep asserting the old version after the source has been fixed. So the run follows the actual link graph from everything that changed to every page that references it, one hop out by default, and further only where a first-hop page changed enough to matter.

Rewriting stale pages in place

Each page a new fact invalidates is rewritten in place and dated as verified that day, with no old claim left standing beside a new note. The agent reads the page fresh just before writing and uses whatever concurrency check the tools offer, so a person's edit in progress is never silently overwritten. What the page used to say is kept on record, which is what makes every change auditable later.

If the knowledge base has a single start-here summary that every session reads first, that summary is treated as derived: rebuilt from the corrected source pages on every run, never edited by hand, and never the only place a fact lives. That is the shape of a company brain that stays current, and how to build a company brain covers the rest of it.

A digest to read, and an alert that stands apart

Every run is recorded: what was read, what was rewritten, how long it took, and what failed. The team gets a short digest, one line of synthesis and then a few bullets grouped by source, short enough to scan in twenty seconds.

The alert is a second, visually distinct message, never folded into the digest. It fires when a day was missed, a source failed, nothing could be read at all, a rewrite did not land, or the run started significantly late. A run that half worked and said nothing is the one failure this kind of system cannot catch on its own, because the digest looks normal either way. The separate flag is what keeps a degraded run from going unnoticed for weeks.