Questions about Korium

Those platforms keep memory inside their own products. By design, saving a preference or decision in one does not make it company memory shared with the others.

Korium gives connected assistants one place to read and write the company’s learning. That can include what came from a meeting, a document, an agent task or another connected tool. It does not automatically copy all of your accounts or conversations.

See the comparison and connection guide.

What that changes in practice

Suppose a client explains in a Teams meeting why a rollout has to happen in phases. You ask a connected assistant to save that decision, its reason and the meeting reference in Korium. Later, a colleague using a different connected assistant can retrieve the decision before drafting the proposal.

The colleague does not need access to your old AI conversation to find the saved explanation. Both assistants use the company memory they have permission to access, and a later correction can be saved there too.

That is what the diagram means by Claude / OpenAI / Gemini / OpenClaw (tested), Teams / Zoom / Meet and Miro / Atlassian / Figma around Korium. These are possible sources and connected clients, not a claim that every tool already has a native connector. The connection, source access and instructions to read and write memory still need to be in place.

No. Once connected, you can ask your assistant to save a decision or find what was learned. The assistant calls the memory tools.

The Mac CLI is for teams that also want to index a codebase. It is a separate setup, not a prerequisite for shared memory. Start with one memory.

Yes. Authorized clients connected to the same Korium workspace can use the same memory. Something saved from Claude Code can be retrieved from Codex later.

You still need the relevant assistant accounts and a working connection for each. Korium supplies the memory, not a subscription to those other products.

No. The diagram shows how sources and assistants can share memory through Korium; it is not a list of native connectors that install themselves.

Teams / Zoom / Meet transcripts and Miro / Atlassian / Figma work can be brought in through an authorized import, a connected assistant or an integration. Claude / OpenAI / Gemini / OpenClaw appear as assistants in that picture; we have tested OpenClaw. Check the actual client’s remote MCP support and account permissions before planning an integration.

If all you need is a place to save notes and find them again, you have plenty of options. The harder problem starts when several people and agents need to use those notes, the decisions change, and somebody has to explain which version applies and why.

Korium keeps decisions, lessons, corrections and handoffs with their sources and relationships. A team can follow a replaced decision instead of receiving two disconnected statements. A connected assistant can use that history without depending on the AI conversation where it was first discussed.

Compare it on a piece of work you recognize

• Save a decision with the reason, source and rejected alternative.
• Correct it later and check whether you can follow both the current decision and the history.
• Ask another authorized assistant to plan the next task and see whether it uses the correction.
• Check the access boundaries, export and review requirements your company needs.

When software is involved, the code map helps the agent locate the implementation behind those decisions. Skills provide reusable instructions, and workflows put the reading, work, review and saving into a repeatable sequence. You can use the parts the job needs.

You could build these capabilities yourself. The question is whether maintaining them is work your team wants to own. Compare the different approaches on those requirements, and check the current security and assurance information; do not assume every memory product has the same capabilities or certifications.

The memory may be new, but the company is not. You already have meeting notes, proposals, decks, project decisions and explanations of what failed. Start with the material that would help somebody do one real job, rather than waiting for everyone to start writing new notes.

1. Choose one project or recurring task, and a small set of relevant source material.
2. Review what may be shared. Have a connected assistant prepare the decisions, reasons, lessons and source references worth keeping.
3. Save or import those memories into the right workspace, with their type, importance and attribution.
4. Open a fresh conversation and ask a real question. Check that the answer finds the saved material and uses its source.

How the first import works

The current korium_hydrate tool imports a batch of prepared memories. It does not take a directory path and read every file itself; an authorized assistant or integration must first read the sources and prepare the entries. Follow the import reference and the batch limits exposed by your connection.

Imports use total storage room, not the ordinary monthly save allowance. Check the plan’s import entitlement and available room before preparing a large batch. A batch that will not fit is refused as a whole.

After the first import, make reading and saving part of the work: consult the relevant memory before a task, then keep the decision, correction or result afterward. Connected meetings and workflows need that setup; they do not all begin capturing automatically. The first-memory guide proves the round trip, then the automation guide helps make it a habit.

Korium searches by both words and meaning, then combines the rankings. It blends that result with the memory’s importance and its activation from use. The question, the company’s material and the history of use all matter.

You can inspect the source memories behind the result. The technical explanation includes the fusion formula and the later ranking step.

Two searches, then a decision about the order

Keyword search finds the words you used. Meaning search can find the same idea expressed differently, such as a note about keeping production running when you ask why the client rejected a single cutover. A normal query runs both searches and combines their positions:

score = 1/(60 + keyword_rank) + 1/(60 + vector_rank)

This is reciprocal rank fusion. A memory near the top of either list gets a larger contribution; a memory absent from one list gets no contribution from that list. Fusion settles the initial ranking, not the whole answer.

The next step normalizes that score and blends it with the importance recorded when the memory was written and activation from its history of use. Activation reflects how often and how recently a memory was brought back. The blend follows the workspace’s configured policy.

The same search words can therefore lead to different results when the available memory, project context or history of use differs. That is not a guarantee of a unique answer for every person, and a frequently used memory is not automatically correct. If either search is unavailable, the result should be identified as partial.

Record the correction and connect it to the memory it replaces. That leaves a chain showing what changed instead of silently rewriting the earlier decision.

A superseded memory may accurately describe what was right at the time. Ask for current guidance when that is what you need, or ask for the history when you want to understand how the decision changed.

Keep what changed, when and who agreed to it

Suppose the client first approved a pilot with the operations team, then agreed to start with customer support instead. Save the new decision, who approved it and the source. Link it to the earlier decision with supersedes, so the next person can follow the change rather than guess which note to trust.

Korium keeps validity information as well as the record of when material was saved. That distinction lets you investigate what applied at a particular time and what the company knew then. It also matters when a change is entered after the meeting where it was agreed.

Where the capture interface supports an attached replacement relation, the memory and link are written in the same transaction. If your client requires separate capture and relation calls, check both results and follow the chain with korium_trace. A successful save alone does not prove the link was made.

A superseded memory is not necessarily wrong. It may be an accurate record of a decision that is no longer current. Preserving that history during a correction is separate from the account deletion and retention rules below.

Some things become dangerous quickly, such as a performance assumption that no longer holds. Other things remain useful for years, such as the reason a team approached a problem a certain way.

Age alone does not settle which is which. Use replacement relationships, evidence and the question being asked. See how Korium treats changing knowledge.

Old is not the same as wrong

A year-old explanation of how you approached a client may still be useful. A year-old assumption about server performance may need checking before anyone acts on it. And if you ask why the approach changed, the old decisions are part of the answer.

Replacement links explain what changed, while use affects ranking. Neither is the same as the automatic expiry implemented for several memory types. The current code does not support a blanket promise that memory never expires by age.

The current implementation also supports automatic expiry by memory type. An hourly job can mark a memory no longer current when it passes the configured age. The repository starts with these defaults; confirm the policy on your service before relying on a retention period.

Expiry removes a record from ordinary current-memory results. It does not delete the stored record, prove the statement false or make storage room. A memory with no TTL can still be replaced explicitly.

Use-based ranking, replacement and expiry are separate mechanisms. For an audit, browse the history and inspect the replacement or invalidation information; do not assume an ordinary search includes every old record. Account deletion and contractual retention follow the applicable terms.

Keep the reason, evidence and replacement links up to date. Neither age nor popularity proves a statement true. The technical guide explains which mechanism changes the result.

Keep the source, review consequential claims and distinguish an imported statement from an approved decision. A retrieved document is evidence, not an instruction that can override permissions.

Correct mistakes explicitly and verify the resulting links. Restrict who can write and review batches before importing them. No memory system makes untrusted text safe simply by storing it.

Make the correction useful to the next agent

Tell the assistant exactly what is wrong and give it the corrected information and source. Have it save who made the correction and connect it to the earlier record, then verify the saved result. A correction left only in the chat will not help an assistant that never sees that conversation.

A person mentioned in a transcript and someone with the same name in a deck are not necessarily the same person. Keep the original references and verify any connection before using it to make a decision.

Use the words your team actually uses

There are two different jobs here. One extraction pass identifies kinds of entities, such as a person or project, using the configured entity labels. The role pass uses a fixed list of roles, not your custom relationship names.

The current role guard permits participant and topic to be stored; the other predicted roles are withheld. Domain vocabulary remains separate from that fixed prompt. Calling a relationship “staffs” or “placed at” can make its meaning clearer to your team, but does not by itself teach the model a new extraction rule.

An explicit link between two saved memories is different from automatically resolving the same person across documents. Check the source and the link you actually received. Do not assume a matching name establishes identity or that saving a correction retrains extraction.

Relationship names such as staffs, credentialed for, sourced through and placed at can describe the work precisely. Register the relevant domain vocabulary and test the actual results, rather than assuming those words become the role model’s prompt.

A wrong-link report is kept separately from a request to remove a link. It becomes a labeled example of the mistaken connection, so feedback can be evaluated without confusing an incorrect relationship with one you simply do not want. Follow the memory and connection checks to inspect the source and correction.

The aim is for a later agent to find the correction and its reason before acting on the old claim. It is not a guarantee that saving a correction instantly fixes every future answer or blocks every malicious source. See the correction and poisoning guidance for the checks to build into the work.

A coding agent often spends time finding the right code before it can change anything. Korium:code gives it a map: the relevant symbols, files and line ranges, together with the commit the answer came from. The agent then reads that source in your checkout.

The map and the memory do different jobs

The map helps find the function that prevents duplicate orders. Memory explains the earlier retry failure and why the check was added. Having both lets the agent investigate a proposed change without making a teammate reconstruct the incident first.

1. The Mac CLI reads the repository and extracts the supported symbols and their locations.
2. It sends the index information to Korium, not the source text. The index can include descriptions that help find a symbol when the question uses different words.
3. A search returns ranked locations and identifies the indexed commit. The agent verifies those locations against the current checkout before using them.
4. Index again as the code changes. Optional Git and task-end hooks can make that update part of the team’s workflow.

The current symbol index supports Elixir / Rust / Swift / Python / shell / JavaScript / TypeScript / Go / Java / Ruby. Markdown, HTML, YAML and Terraform are not part of that symbol coverage today. Use file search for those instead of assuming an empty code-search result means the content is absent.

The map narrows the search; it does not certify a change, replace tests or make stale locations safe to trust. Follow the code-indexing guide, then the Git and GitHub guide if you want to keep it updated through your existing workflow.

Total room counts the memories the account holds. The monthly save allowance counts ordinary new captures during the billing period. Room does not reset each month.

Current amounts and account options are on the pricing page. We keep those figures in the account system rather than duplicating a price list here.

New saves pause. Hitting a save or room allowance does not remove the memories already held, and reading and searching remain available while the account otherwise has access.

A monthly allowance renews with the billing period. Full storage room needs more room or a suitable plan. Don’t keep retrying a refused capture and report it as saved.

Save responses warn as an allowance approaches its limit and include the usage figures. An assistant should show that warning rather than hiding it inside a tool result.

Check the account’s actual usage before starting a large import or a workflow that will create many memories.

No. It changes how the memory should be understood, not whether it exists. A superseded memory still counts toward the room used.

Marking true material untrue to solve a storage problem would make memory less trustworthy. That is not a storage-management option.

A prepared import uses total room but does not consume the ordinary monthly capture allowance. A batch that will not fit is refused as a whole.

The free plan has a different import entitlement from paid plans. Check the plan and review the batch before you start, rather than assuming an import is unlimited storage.

No. Filling a save allowance is handled by pausing new saves, not by quietly discarding older material. Corrections and supersession preserve the record.

That product behavior is separate from account closure and contractual retention. Those are covered by the terms and DPA.

The normal memory workflow corrects, supersedes and connects records rather than removing individual memories. Supersession records what changed; deletion would leave a gap in the history.

Do not store credentials or material you do not have permission to keep. For an account-level deletion request, contact reports@kyroco.ai and follow the published data terms.

Yes. Export is available across plans. Keep a copy before closing an account, and verify it contains the material you need.

If an account is terminating, use the retrieval period described in the terms. Do not assume cancellation means indefinite access.

Existing memories are retained under the account’s applicable terms. If they exceed the smaller plan’s room, new saves remain paused; superseding records cannot bring you back under that limit.

Review the account’s plan-change information before switching. Moving to a smaller allowance is different from requesting deletion of the account.

Cancellation, the end of the paid period and the post-termination retrieval period are different events. The terms describe when access ends, the export window and subsequent deletion or de-identification.

Export before that window closes. If you want to request earlier account deletion, write to reports@kyroco.ai. Backup retention and legal exceptions are covered in the same published documents.

Your practical protection is the ability to export the material. Keep copies on a schedule that fits how important the memory is to your work.

We won’t invent a continuity guarantee that is not in your agreement. Ask about any requirements your company needs before relying on the service.

Access is limited to the authorized workspace and the people or clients permitted to use it. Roles control allowed actions; a project scope is not a private compartment inside a shared workspace.

Korium enforces tenant separation at the data layer. Read the access guide and published security controls for the boundaries that apply.

The terms prohibit Kyroco from using Customer Content to train, fine-tune or improve general-purpose or foundation models. They also explain the use of providers for memory operations.

“Not used for training” does not mean “no processing.” Review the subprocessor list and the terms of any assistant you connect, since that assistant receives the memories it retrieves.

The service’s security and data-processing documents describe its hosting, encryption and default processing arrangements. A specific residency commitment needs to be part of the agreement that covers your account.

Ask about regional requirements before sending restricted material. Use the security overview and DPA as the current sources.

Do not treat this website as a claim of certification. Check the security page for the current assurance information and ask us for the material your review needs.

Controls aligned to a framework and an independent audit are different things. If a completed audit is a requirement, establish that directly before signing.

Your company keeps ownership of the material it puts into Korium. The service separates customers at the database layer and encrypts data in transit and at rest. The published controls describe no standing path for Kyroco staff to read a customer’s memory.

What those protections mean

Database-enforced row-level security limits a connection to the tenant it is authorized to access. That protection is separate from the roles and permissions that decide who within your organization can read or write. Giving a connected assistant access means it can receive the memories it is authorized to retrieve.

Kyroco’s terms prohibit using Customer Content to train, fine-tune or improve general-purpose or foundation models. Memory operations still involve processing: the published security description covers extraction and embedding inside Kyroco’s environment and a managed model used for higher-level memory operations. Review the subprocessors and the data terms of any assistant you connect.

You can export your material. When the service or engagement ends, retrieval, deletion and backup retention follow the agreement that applies to your account. Establish those requirements before the work starts; do not assume ending an engagement deletes every copy immediately.

The security overview, terms and DPA are the current sources for those commitments. They also distinguish security controls from a completed independent certification. If you require a particular audit, residency arrangement or self-hosted setup, discuss and document it before sending restricted material.

A team account has shared memory. Something a colleague saved can inform another authorized person or agent later. That is the purpose of the workspace.

If groups need to be isolated, configure that separation at the account or organization level. Different scope names do not create access controls.

The team’s allowance is shared, rather than divided into equal personal portions. One person may do most of the capturing while others mostly read.

Watch the shared usage and review automated capture volume. Lots of writes are not useful if they make the memory noisy.

Workspace administrators manage membership and access. The work already captured remains company memory when a person leaves.

Seat and allowance changes follow the account’s plan rules. Storage room is not shrunk to discard existing team learning when headcount falls; check the account’s current billing and allowance figures for the effect of a change.

Team memory belongs to the organization. The product does not provide per-person erasure from that shared record; account-level deletion follows the organization’s authorized instructions.

The organization is responsible for handling individual data requests under its obligations. The DPA explains the controller and processor roles. Raise a request with your administrator rather than assuming a display-name change removes the underlying material.

Memory records capture attribution and can include who made a decision, the agent that wrote the capture and the phase of work. Those are distinct roles.

Keep the attribution accurate. A human’s approved decision should not be inferred solely from an agent’s name. The capture guide explains what to record.

Not everything in a one-on-one belongs in company-wide memory. A transcript might contain a useful project decision alongside personal information. Decide what the team needs to keep and who should be able to read it before importing the whole conversation.

For example, save the agreed change to a project deadline with a source reference that the intended readers may access. Leave the unrelated private discussion out. Keeping the useful decision does not require keeping everything said around it.

Sharing needs a real access boundary

A team workspace is shared memory for its authorized members and clients. Names such as personal, marketing or engineering can organize records, but a memory scope is not an access control. Do not treat a scope label as a private brain that only its author can read.

If individuals, departments or clients need separate access, establish that separation through the account or organization setup and verify it with the administrator. Share an approved decision into a wider workspace deliberately, with its source and attribution, only when those readers should receive it.

When someone leaves, administrators remove their access while the organization keeps the work it is entitled to retain. Export, deletion and individual data requests follow the applicable terms and the organization’s instructions, not an assumed automatic deletion date. Start with sharing and access before adding sensitive material.

The account preserves the applicable allowance protection for an existing subscription rather than silently reducing what it bought. Increases and billing-period changes are reflected through the account’s plan rules.

Review the actual subscription and effective dates in the account. The pricing catalog and your agreement are the right sources for a specific change.

Eligible plans offer additional room and monthly-save overage. They solve different problems: more storage room does not replace a monthly capture allowance, and save overage does not buy permanent room.

Overage is opt-in. Review the amount, spending controls and any carried credit in the account before enabling it. The current offer and prices belong on the pricing page.

A payment problem can pause new saves without deleting the existing memory. Follow the billing notice and resolve the payment through the account.

Payment-related restrictions and eventual termination are governed by the terms. Do not confuse a temporary read-only state with a promise that a closed account remains accessible forever.

Capture acknowledges the stored record before every extraction and indexing step has finished. Background work makes the memory available through the relevant retrieval paths.

The useful checks are the capture receipt and the later search result, not a fixed latency promise. Busy periods, partial searches and indexing failures should be reported as such.

Plan allowances and background memory operations can differ. Check what the account includes before relying on automatic consolidation or a particular workflow.

The capability guide explains what the components do. The account describes which features and allowances are available to you.

A save creates work: accepting the record, extracting and indexing it, and keeping it. Reading is how you get value from that work later.

The save allowance governs additions. It does not make old memories disappear when you use it up.