tethercode.
Get early access

tethercode / knowledge engine

A memory your agents can be held to

Every answer names the record it came from. Documents are kept whole, one thing has one name, a guess is never saved as a fact, and all of it lives in your own database.

A knowledge engine, not a notes file

Most AI memory works the same way: cut every document into pieces, find the pieces that look like the question, and let the model write. Four things go wrong with that, and none of them can be tuned away. More of the work in tethercode went here than anywhere else.

The same thing gets three names

"Ledger service", "ledger-svc" and "General Ledger" become three sets of facts, or two different things quietly become one. Every answer after that is about the wrong thing, and nothing tells you.

Here: a name is settled as a decision, with a record. A match has to fit the kind of thing, pass a check and be the only candidate left. Two close candidates are reported as unclear, never guessed.

Cutting a document up destroys what it meant

A figure loses the period it applied to. A finding loses the condition that limited it. The model stitches the fragments into something fluent and unsupported.

Here: the file, the exact text and the summary are kept as three separate things. A summary can never stand in for the record, and what does not fit is left out whole and named, never cut in half.

Guesses get saved as facts

When a model's output is written straight back into memory, tomorrow's answers are built on today's guesses, and there is no clean point to go back to.

Here: only what must follow from known facts is kept. Anything it merely suspects waits until a person accepts it, and who accepted it is recorded.

It finds text. It does not think.

Looking up similar paragraphs cannot work out a consequence, notice a pattern across cases, or explain something no single document states.

Here: it reasons over what it knows in three ways: what must follow, what usually holds, and what would explain this. Every result shows its steps.

It can reason freely because it cannot promote its own guesses.

A memory you can check

Every answer names the record it came from, the original is one step away, and all of it lives in your own database.

Asked: what did we decide about token lifetime?
Answer
Tokens last 30 minutes and the refresh window slides.
From
a decision recorded on 12 November open the original
From
auth-design.pdf, version 3, section 41 open the original
Lesson
renaming the expiry field broke the mobile client seen twice, evidence attached
Not found
anything about rotating refresh tokens

It says what it could not find instead of filling the gap.

For you

Search that answers, and admits when it cannot

A question gets an answer, the facts behind it, and the stored record each fact came from. When the records do not hold the answer, it says so.

The original is never lost

A summary is labelled a summary and can never be handed over as the record. The exact stored text is one call away.

Nothing is lost when something is down

A memory is either saved or visibly waiting. Work that needs a helper which is not answering waits and retries, and you can see what is stuck and why.

Forgetting really forgets

Delete a memory and it is removed from search, from the connections drawn from it and from storage, as one job. A memory can also carry an expiry date.

Each project keeps to itself

Every memory is written to a named place: one repository, one project, or everyone. One project's notes do not drift into another's answers.

For your agents

They are captured without being asked

What each agent said, did and got back from its tools is recorded as it works. If the memory service is down, the record waits on the machine and is delivered later. Nothing is dropped.

Lessons from finished work come back

When a task closes, what happened is distilled into lessons, each tied to its evidence. The same trouble a second time strengthens the existing lesson. A lesson becomes a standing rule only when you say so.

A corrected fact stays corrected

A correction records which fact it replaced and keeps the old one for the record. Two facts that disagree are reported, never quietly settled.

Sensitivity only goes up

Every record carries a sensitivity mark. Anything derived from it inherits the strictest mark among its sources, and an agent without access is told how much was withheld, not shown it.

What they produce has an owner and an end date

Reports, files and drafts go into a store with versions, sharing by explicit grant and a stated lifetime, instead of being scattered through chats and temporary folders.

Documents, distilled without being thinned

Drop in a design document, a contract or a spreadsheet. tethercode keeps the file, reads it properly, and turns it into something every agent can search, cite and reason over.

vendor-contract.pdf, 60 pages
Kept
the exact file you gave it, fingerprinted
Read
into clean text, with a note of which reader supplied which part
Sections
214, word for word, each with its own summary beside it
Understood
the vendor, the renewal date and the notice period, filed under terms you already use
Ready
searchable. Version 2 will replace version 1 in one step, and version 1 stays in the history
If stuck
it waits, says which helper it is waiting for, and tries again

The summary sits beside the text. It never replaces it.

For you

The file you gave is the file it keeps

The original is stored untouched, and the same file is never uploaded or processed twice.

Read properly, not scraped

PDF, Word, PowerPoint, Excel, CSV, web pages, Markdown and plain-text formats. Several readers work on a PDF together and their results are merged. A scanned page is recognised as a scan and can be put through text recognition.

You can see where every document is

Uploading, being read, ready, or waiting, with the reason. That stays true after a restart.

Versions, and a real delete

A new version replaces the old one in a single step, with the history kept. Deleting a document removes the file, its sections and everything learned from it.

An attachment answers straight away

Attach a file in a conversation and its whole text is there to answer from, never trimmed to fit. It joins the shared knowledge only if you say yes.

For your agents

They cite the document, the version and the section

An answer drawn from a document points at exactly where, so anyone can check it.

They read the exact words

Summaries help find the right section. The answer is written from the text itself.

What is in the document becomes something to follow

The people, systems and terms a document mentions, and the links between them, are added to the same knowledge everything else draws on, each tied back to the document.

They do not pay twice

A section that has not changed keeps its summary. Work that was interrupted picks up from what was already done.

Tables and databases too

A spreadsheet or a database table can be loaded as reference facts and kept up to date as rows are added.

One vocabulary for everything it knows

Before facts can be compared, searched or reasoned over, everyone has to mean the same thing by the same word. tethercode keeps an agreed list of the kinds of things and the kinds of links between them, and holds every document and every agent to it.

The life of a term: "feature flag"
Seen
in three documents. No kind fits, so it is kept as a possible new kind, not forced into a wrong one
Proposed
you give it a name, a definition and the kind it belongs under
Checked
a logic checker confirms the vocabulary still does not contradict itself
Published
as version 14. Version 13 is one step back
From now
new documents are filed under it
Not done
nothing already stored is quietly relabelled. You are shown what would change

Anyone can draft a change. Only an administrator can publish one.

For you

It arrives knowing a great deal

It ships with 310 kinds of thing and 456 kinds of link, grouped by subject and switched on by profile: software, data science, finance, biology and more.

It grows from your own documents, and you decide

Terms your documents use that the vocabulary lacks are collected for you. Each one becomes part of it only with a name, a definition and a place you give it.

Changes are safe

Draft freely. Before anything is published, a logic checker refuses a vocabulary that contradicts itself. Each publish is a numbered version you can compare with the last and roll back to.

Two names for one thing, joined. The wrong two, never.

When "ledger-svc" and "Ledger service" are joined, a search for either finds both, and the join can be undone. "Heartbeat" the album is never merged with "heartbeat" the pulse.

Checked against the outside world

Terms can be looked up in 23 public reference sources, among them Wikidata, the Library of Congress, MeSH and GeoNames. "Nobody could be asked" is reported apart from "nothing matched".

For your agents

They cannot invent a category

When a model sorts something into a kind, its answer is limited to the kinds in the vocabulary, or "none of these". A made-up kind is not something it is able to write.

A link is checked before it is stored

"Calls", "owns", "depends on": each link has to join the right kinds of thing in the right direction. One that does not fit is not written as if it did.

A hedge stays a hedge

"The team said", "it might" and "it does not" are stored as reported, possible and denied. An agent does not later read a rumour as a fact.

Facts with a shape they can reason over

An agent can ask what a thing is, what else it is called, what it is connected to and what the evidence is, and get the same answer whichever document it came from.

A small model does the sorting

Routine sorting goes to a small, fast model. A larger one is asked only when the small one is unsure, so your best model is not spent on filing.

Reasoning you can audit Premium

A language model tells you what it thinks. This works out what must follow from what is already known, shows the steps, and says what it could not check.

Reasoning review
Worked out
the billing team depends on Session.refresh from 2 facts, by the rule "depends on carries through"
Disagree
the design document says tokens last 30 minutes, the runbook says 60 reject one, keep both, or they are the same thing
A guess
the tax step should run before the invoice is built supported by a path through 3 functions
Not checked
this run could see four kinds of disagreement. The kinds it could not see are listed
waiting for you Make the guess a fact? ConfirmRejectyour name goes on it

For you

Every conclusion shows its working

Each new fact names the rule that produced it and the facts it came from. Take one of those away and anything that rested only on it goes too.

"No contradictions" comes with the small print

Every result states which kinds of disagreement it was able to see and which it was not, so a clean result can never be read as more than it is.

Disagreements are found, not smoothed over

Two records that cannot both be true are put in front of you together. You decide: reject one, keep both, or say they are the same thing.

Nothing becomes a fact without you

A guess, or a rule it has learned from examples, waits in a review queue. Confirming or rejecting records who decided and when. A rejected idea is kept on the record with its verdict.

Rules it learns are held to a cautious standard

A pattern is scored on the low side of what the examples support, and what was left out for lack of evidence is counted and shown.

For your agents

A failure, traced through the code

An agent hands over the function that failed and the error. Back come the likely causes in order, each with the path through your code that supports it, how far the search went, and what earlier attempts already found.

The same answer twice

Working out consequences, mining rules and ranking explanations are fixed logic, not a model's opinion. The same facts give the same result every time.

It cannot point at something that is not there

Where a model is used to put an explanation into words, it can only refer to facts and links that exist.

Long runs do not block

A run starts in the background and survives a restart. The agent carries on and collects the result when it is ready.

A plan that knows what it stood on

A plan drafted from a goal records the facts it relied on, and can report whether any of them has changed since.

Research that keeps its sources

Ask for a brief and get a report in which every claim opens the page it came from, kept as it was on the day it was read.

Research run: a competitor brief
Planned
6 sections and the questions each one has to answer, before a single search
Found
61 pages. 38 admitted, 19 set aside as off the subject, 4 refused as unsafe
Kept
every admitted page, whole, as it was when read
Written
section by section, each claim tied to the page it came from
Delivered
as Word, Markdown and JSON
Gaps
"pricing for the largest tier": nothing reliable was found, and the report says so first

Stopped because every section was covered. It always says why it stopped.

For you

Every claim opens its source

Each citation carries the address, the time it was read and the exact passage. The whole page is kept, so the claim still stands when the site changes or disappears.

A plan before a search Premium

A planned run breaks the brief into sections and the questions each must answer, then reads until every one is covered or no more progress can be made. It survives a restart without reading or paying for anything twice.

It leads with what it could not find

The report opens with the argument, the first thing to do and the gaps in the evidence. A search engine that could not be reached fails the run. It is never passed off as "nothing found".

You can see everything that went out

Every question sent, every page fetched and whether it was admitted, in the console. One click stops a source being used again.

Your own data alongside the web

A run can draw on company sources you have access to as well as public pages, and on documents it already holds before fetching new ones.

For your agents

Search and fetch, in every edition

Two plain tools any agent can call, through a search engine you host. A failure comes back as an answer the agent can act on, not a crash.

Fetch with a purpose

An agent says what it is looking for and gets back the passages that bear on it, not forty thousand words of page.

A web page cannot give orders

Fetched text is handled as untrusted material that can never become an instruction. A page that looks like an attempt to steer the model is kept and reported, and never shown to it.

It cannot make up a citation

The only sources a model is able to cite are the pages it was actually given for that passage.

Your network is off limits

Only public web addresses are fetched, checked again at every redirect. An address inside your own network is refused.

More of tethercode

Try it on your own repository.

Free for 3 repositories, with no time limit and no card. One email when it is ready, and nothing else.

Deploying for a company? Talk to us. Prices are on the editions table.