Keep the work beyond the conversation.
Akasha is the engine inside your Mind. Its storage layer keeps task state, session records, and application data available for the next step. Underneath, AkashaKV organizes that information as named records you can save, update, and retrieve.
Akasha engine
The foundation
that holds the work.
Write a record. Keep its history. Read a consistent version when you need it.
A write has somewhere to land.
Akasha records a write before moving it through storage.
Built for information that keeps changing.
An agent may update a task, save a result, and read earlier context in the same workflow. AkashaKV organizes those writes and reads beneath the memory, graph, and retrieval features of Minds.
- 01Record writes for recoveryA write-ahead log (WAL) records changes before they move into long-term storage. Group commit saves batches together.
- 02Handle writes in parallelSeparate write buffers let worker threads prepare data concurrently before it is combined for storage.
- 03Move active data to diskNew writes collect in an in-memory buffer, called a memtable. A flush moves that batch into the first storage level.
- 04Keep stored data organizedCompaction combines stored files into levels, keeping growing datasets organized for reads.
- 05Keep frequent reads closeA frequency-aware cache gives frequently requested records priority, reducing repeated trips to storage.
- 06Read a consistent versionMulti-version concurrency control (MVCC) keeps versions of records so readers can use a consistent snapshot while updates arrive.
Save a record. Pick it up later.
Create a named collection, save a project record, and retrieve it by the returned identifier. This HTTP example uses document storage backed by AkashaKV.
// Run server-side with credentials scoped to this Mind.
const endpoint = process.env.AKASHA_URL;
const capability = process.env.AKASHA_CAPABILITY;
if (!endpoint || !capability) throw new Error("Configure your Mind connection");
async function request(method: string, path: string, body?: unknown) {
const headers: Record<string, string> = {
"Content-Type": "application/json",
"x-akasha-capability": capability!,
};
if (process.env.AKASHA_TOKEN) {
headers.Authorization = "Bearer " + process.env.AKASHA_TOKEN;
}
const response = await fetch(new URL(path, endpoint), {
method, headers,
body: body === undefined ? undefined : JSON.stringify(body),
});
if (!response.ok) throw new Error("Mind request failed: " + response.status);
return response.json();
}
// Create once. The capability must permit administration of project_state.
await request("POST", "/v1/keyspaces", {
name: "project_state", model: "document",
});
const saved = await request("POST", "/v1/project_state", {
data: { project: "Q3 review", nextStep: "Compare revenue by channel" },
});
const record = await request("GET", "/v1/project_state/" + saved.id);The foundation beneath your Mind.
Versioned storage keeps reads consistent. A recovery log records changes, and caching keeps frequently used data close. Choose instance capacity to match the work your agents run.
- Record model
- Key-value pairs
- Recovery log
- Write-ahead log with group commit
- Read isolation
- Versioned snapshots (MVCC)
- Organization
- Log-structured storage with compaction
- Caching
- Frequency-aware admission
- Write
- Save a document and receive its identifier
- Read
- Retrieve a document by collection and identifier
- Browse
- Query records within a collection
- Organization
- Named keyspaces
- HTTP
- /v1/keyspaces · /v1/:keyspace/:id
Give your agents somewhere to keep the work.
Start with a dedicated Mind, powered by Akasha. Add the memory and retrieval your application needs as you build.