We’re building Ever Works in public. Some things may be incomplete, missing, or broken while we continue improving the platform.We’re building Ever Works in public — expect a few rough edges.
Knowledge · Ingest, search, cite
A knowledge base is only worth having if getting material into it is trivial and getting an answer out of it is trustworthy. Ever Works takes the file you already have — a 200-page brand PDF, a quarterly spreadsheet, a recorded strategy call — stores the original untouched, writes a clean Markdown extract into your own Git repository, embeds it for retrieval, and then shows you which chunk of which document produced any given claim.
Every upload keeps the original verbatim in your storage plugin and writes an agent-readable extract into the Work’s Git data repository at .content/kb/<class>/<slug>.md, with a .yml sidecar beside it. Agents never read the binary — they read the extract, and its class is what tells them how to use it.
An uploaded PDF has its text layer extracted in process and wrapped as a Markdown body — no re-fetch over HTTP, so a private storage backend behaves like a public one. For scanned PDFs behind a source URL, enable the optional pdf-extractor plugin and give it a Mistral API key: below 100 characters per page it treats the file as scanned and re-reads it with Mistral OCR, 50 pages per document by default. Without that key the plugin still does text-layer extraction — it just has no OCR to fall back on.
Upload .docx and it becomes Markdown; .xlsx and .xlsm become one Markdown table per sheet, capped at 10,000 rows; .pptx becomes one section per slide, capped at 1,000 slides. Legacy .doc, .xls and .ppt are deliberately not routed — convert and re-upload. Office files behind a URL need the optional officecli-extractor plugin.
HTML and XHTML convert to Markdown with real headings and fenced code blocks. Source URLs a Work generates from take the content-extractor chain instead, with local-content-extractor as the built-in default and a 25 MB download cap plus an SSRF guard on the optional plugins.
The notion-extractor plugin reads Notion pages — public ones directly, private ones through the Notion API with your token. It installs from the plugin registry and is off until you enable it on the Plugins page.
Video is normalised to MP4 with its audio track pulled out as MP3; a bare recording is normalised to MP3. Whichever AI plugin advertises the transcribe capability then produces the text — OpenAI Whisper today — and it lands as a research-class document filed under a transcripts/ path and tagged transcript (the target class is configurable, via KB_TRANSCRIPTION_TARGET_CLASS), with a sidecar recording the source upload, the duration and the detected language.
Markdown and plain text pass through UTF-8 decoded; CSV and TSV become a single Markdown table. Bodies are capped at 1 MiB and a truncation is marked in the text rather than hidden — the original stays whole in storage and stays downloadable.
Retrieval is hybrid and every use of it is recorded, so "why did it say that?" has an answer you can click rather than a shrug.
A lexical filter and a vector nearest-neighbour search each produce a ranked list, and the two are fused with Reciprocal Rank Fusion at k = 60. Because RRF uses ordinal rank rather than raw scores, swapping the embedding model never forces a re-tune, and ties break by document id so the search palette does not flicker between renders.
Chunks are embedded through your AI provider and written to a pluggable vector store: pgvector by default, in the API’s own Postgres, with every query row-filtered by Work. Qdrant installs from the registry and gives each Work its own collection. Nothing is hardcoded — a Work can override the choice on its own plugins tab.
Every document injected into a run is logged, and every use is recorded as a citation. The Ask why panel in the workbench shows the deterministic trail behind an answer, and generated pages carry citation markers that jump straight to the source document.
In the editor, @kb:brand/voice pins a document into the prompt and @upload:<id> embeds a viewer for the original. Cross-references between documents become first-class links, and those links are what the citation graph is built from.
A full lock rejects every agent edit; additions-only lets an agent append research but never rewrite what is there. Because each document is a committed .md plus .yml pair, history and restore are real Git operations — and every lock change is an activity-log event carrying the actor, the mode and the previous state.
A decision-class document moves proposed to accepted to superseded to archived, and a supersede records the chain on both documents so a reader always lands on the rule in force. Anything an agent writes arrives as proposed and is withheld from context injection until a human accepts it in the Work’s review queue.
Publish a document once at the organization level and every Work inherits it — legal, style and seo only, deliberately, so a house rule can be centralised without an org-wide document silently redefining a single Work’s brand or personas. A Work that needs a different answer writes its own document at the same path and that one wins. A proposed document never inherits and never shadows, on either side.
The Knowledge Base is per Work. Memory, in the dashboard sidebar, fans in every Work’s documents plus the ones published at the organization level — the same rows, aggregated, never a second copy.
One search box over everything the organization knows, with chip groups for Type, Work, Source and Status — each chip carrying its own count, and Clear all resetting the lot. The header reports what it is searching, for example "428 documents indexed · 12 Works".
Press Consolidate and you get a report first — scanned, promoted, synthesized, superseded — because a bare run is always a dry run. Apply persists the markers: the strongest documents are promoted, near-duplicates are marked superseded and point at the survivor, and a cluster of three or more is merged into one document filed as proposed for review.
Recall hit rate answers whether the documents you injected were actually cited afterwards; stale decisions, review backlog with its oldest age, and gap topics answer the rest. A rate that cannot be computed reads "Not measurable yet" with the reason rather than a misleading zero, and the gap topics are fed into the next consolidation run.
Every file you can see — chat attachments, plain uploads and Knowledge Base originals — in folders you define, Global or private to a single agent, each row labelled with where it came from. Point a folder at a repository, press Sync now, and it commits and reports how many files landed and how many were skipped.
Meetings are a source, not a silo: transcripts ingested from Zoom or Google Workspace become summaries and memory automatically, and the catalog renders as a block on the Memory page filterable by source and by the Work a meeting was routed to.
What the agents themselves remember from their runs, listed read-only with each session’s start time and whether it is open or closed. The backend is plugin-provided, so when no provider is enabled the panel says exactly that instead of quietly rendering an empty list.
Four steps, and you can watch each one land.
Open the Work’s Knowledge Base, switch to the Originals pane, and drag the file onto the tree — or run ever-works kb upload from a terminal, or POST to the uploads endpoint. For material that belongs to the whole organization, drop it on the Originals panel of the Memory page instead. Watch the chip move Pending, Extracting, Extracted.
Choose the class on upload or let the platform suggest one, then confirm class and tags in the metadata panel. The class is the whole point: legal is copied verbatim and never paraphrased, glossary substitutes your approved terms, personas decides who the writing is aimed at, and research is retrieved by similarity when it is relevant.
The extract is written into your Git data repository as a commit, chunked, embedded through your AI provider, and stored in the vector store the Work resolves to. A failed extraction grows a Retry extraction action; a file with no extractor route keeps its original and says so, so nothing disappears silently.
On the next run, kb_search and kb_read pull the document into context, brand and legal and glossary get injected deterministically under a token budget, and every use is cited. When an agent files something new with kb_write it upserts by path and arrives as proposed, so it waits in the review queue rather than teaching itself its own claims.
The same knowledge base is reachable over REST, from an MCP-compatible assistant, from the CLI, and from platform chat — which grows a Cited footer under an answer whenever you are reading a Work, one chip per referenced document however many times it was quoted, because the chat surface derives the Work scope from the page you are on. All of them are thin surfaces over the same endpoints and the same access controls, so a script and a chat message get the same answers and obey the same locks. The limits below are real and worth knowing before you plan around them.
A per-Work, Git-backed store of brand, voice, research, and rules that every generation reads from — your built-in wiki and memory.
Learn more →Agents recall what your team already decided. Recall is injected into every run, decisions are recorded and reviewed, and superseded knowledge retires itself.
Learn more →Manage Works from any MCP-compatible assistant — 127 API tools plus Knowledge Base tools, authenticated with an API key, over stdio or HTTP.
Learn more →Create, generate, deploy and register Works, manage plugins and the knowledge base from your terminal — npm install -g ever-works-cli.
Learn more →Every operation in the dashboard is also a sentence in the chat rail — confirmed before anything destructive, and answered with live charts, tables and boards.
Learn more →Drive the platform from Slack, get pull requests reviewed against your knowledge base, and turn meetings into memory.
Learn more →Describe what you want to build. Ever Works researches it, ships it, and keeps it improving — content and code, owned in your own Git.