1. Connect
Creative: Point Kumiho at your storage: local disk, NAS, or S3.
AI: Connect via MCP, Python SDK, or REST API.
Shared: Your data stays where it is. Kumiho tracks the history layer.
One architecture. Two superpowers.
Assets have history. AI memories should too.
One system for versioning creative work and persistent, auditable memory for your AI assistants.
Free tier available. Start with one folder or one MCP connection.
Creative revision history
AI memory graph
Session Memory
graph-native- Preference: cinematic lighting, low contrast
- Decision: switched to SDXL refiner pass
- Fact: hero mesh depends on base_rig_v17
- Reasoning: color grade follows reference board v5
Same graph. Same API. Same provenance guarantees.
Two paths, one architecture
Choose your entry point. Both run on the same graph-native foundation.
Version control for creative work
Track every revision of every asset: models, textures, renders, and AI outputs. Keep full history, attached metadata, and visible dependencies without moving files.
See how it works for creatorsPersistent memory for AI agents
Give assistants memory that survives sessions, model upgrades, and context limits. Graph-native, auditable, and decoupled from any single LLM provider.
See how it works for AISame graph. Same API. Same provenance guarantees.
How it works
One flow, two applications.
2. Track
Creative: Every save becomes a revision with prompts, metadata, and parameters attached.
AI: Every decision, preference, and fact becomes a versioned memory node.
Shared: Immutable revisions. Typed dependencies. Full provenance.
3. Query & reason
Creative: Search any version, trace dependencies, and automate on change.
AI: Recall context across sessions, traverse reasoning chains, and consolidate overnight.
Shared: One query surface for history, causality, and impact.
One graph that answers 'what happened, why, and what depends on it.'
The problem isn't storage. It's losing context.
Whether you're tracking creative assets or AI reasoning, the failure mode is the same.
The pain
Creative: Versions explode. Metadata disappears. Nobody knows what depends on what.
AI: Context windows reset. Memories hallucinate. Decisions have no provenance.
Shared: You can't reason about what you can't trace.
The fix
Every output becomes a versioned node with metadata attached.
Relationships are explicit and typed, not inferred from embeddings alone.
History is immutable. Beliefs evolve through revisions, not overwrites.
Dream State consolidation runs async: enrich, link, and prune with safety guards.
What makes Kumiho different
LLM-Decoupled Memory
Memory lives in the graph, not a model context window. Switch providers and your history stays intact.
BYO Storage
Raw files stay on your disk, NAS, or S3. Kumiho tracks metadata and pointers with no forced uploads.
Immutable Revisions
Nothing is silently overwritten. Every change creates a new revision with full auditability.
Typed Dependencies
Edges like DEPENDS_ON, DERIVED_FROM, and SUPERSEDES encode why nodes are connected.
Hybrid Retrieval
Full-text, graph traversal, and vector similarity are fused into a single relevance-ranked response.
Dream State
Async consolidation enriches memory, links related items, and prunes noise while protecting published nodes.
40-280x Token Compression
Store summaries in the graph while full content remains local, reducing memory retrieval token cost.
Patent pending. Built on production asset management primitives proven in VFX and game studios.
Find your path
Creators, studios, AI builders, and developers run on the same foundation.
For Creators
- Turn messy folders into a searchable library
- Retain prompts, models, and seeds on every output
- Find the exact version you need in seconds
- Share work cleanly while preserving full history
Learn more
For Studios
- Know what changes break before they do
- See cross-asset connections at a glance
- Lock published revisions with access controls
- Align distributed teams on latest versions
Learn more
For AI Builders
- Give agents persistent memory across sessions
- Store decisions, preferences, and facts as versioned graph nodes
- Traverse reasoning chains: 'why did the agent decide X?'
- Use one memory_store call to create item, revision, artifact, and typed edges
Learn more
For Developers
- Build on stable gRPC and REST APIs
- SDKs for Python, Rust, C++, and Dart
- Permanent kref links that resolve across time
- Webhooks and events for automation pipelines
Learn more
Designed by pipeline engineers who've shipped production creative workflows, now extended to give AI agents the same rigor.
Sub-10ms graph queries at production scale
40-280x token compression vs raw context
Patent-pending architecture filed with USPTO
Set up in minutes without moving files
How Kumiho compares
A direct view of what is built in versus what needs custom glue.
Creative Asset Management
| Capability | Kumiho | Git LFS | Perforce | DAMs (Shotgrid, ftrack) |
|---|---|---|---|---|
| Files stay on your storage | Yes | No (repo) | No (depot) | No (upload) |
| Typed dependency tracking | Yes | No | No | Limited |
| Immutable revision history | Yes | Yes | Yes | Varies |
| AI-generated asset support | Native | No | No | Bolt-on |
| Metadata-first (no file moves) | Yes | No | No | No |
AI Memory
| Capability | Kumiho | Mem0 | Zep | LangGraph | Raw vector DB |
|---|---|---|---|---|---|
| LLM-decoupled | Yes | No | No | No | Yes |
| Graph-native (not just vectors) | Yes | No | Partial | Yes | No |
| Immutable revision history | Yes | No | No | No | No |
| Typed reasoning dependencies | Yes | No | No | Partial | No |
| BYO storage (local-first) | Yes | No | No | No | Depends |
| Async consolidation (Dream State) | Yes | No | No | No | No |
| Formal retrieval guarantees | Yes | No | No | No | No |
Frequently asked questions
Do I need to upload my files?
No. Files stay on your storage. Kumiho stores references, metadata, and revision history.
Can I start small?
Yes. Start with one folder or one MCP connection and expand only when it proves value.
Is my revision history safe?
Yes. Published revisions are immutable and cannot be silently overwritten.
Does Kumiho replace my DAM?
No. Kumiho complements existing DAM systems with versioning, lineage, and graph reasoning.
What file types are supported?
All of them. If you can reference a file, Kumiho can track it.
Is it for individuals or teams?
Both. Individuals use it for recall and reproducibility. Teams use it for governance and shared context.
How is this different from just using a vector database?
Kumiho stores versioned, typed graph nodes with provenance and dependency tracking. Vector similarity is one retrieval mode, not the memory model.
Does my AI's conversation data leave my machine?
Full conversations can stay local as markdown artifacts. Short structured summaries are what sync into the cloud graph.
What happens when I switch LLM providers?
Nothing breaks. Memory is graph-resident and model-agnostic, so history carries across provider and model changes.
What is Dream State?
Dream State is async consolidation that reviews memory, enriches metadata, links related items, and prunes noise with safety guards.
How do I integrate with my AI agent?
Use one MCP tool call or the Python SDK. A single memory_store operation can create item, revision, artifact, and edge relationships atomically.
Ready to give your work and your AI a memory?
Join creators, studios, and AI builders who trust Kumiho to remember what matters.
Free tier available. Start with one folder or one MCP connection.