Kora – Local-First AI Orchestration for macOS

TL;DR

TL;DR: Kora is a local-first AI orchestration system for macOS that turns your files, notes, and workflows into a queryable knowledge graph — all data stays on your machine.

Source and Accuracy Notes

This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: intuitivecompute.com
• Product: kora – Cloudless Enterprise AI Assistant
• HN launch thread: news.ycombinator.com/item?id=47794514 (via YC W26 batch)
• License: Proprietary (paid, no open-source license detected)
• Source last checked: 2026-06-19

What Is Kora?

Kora is an AI-native OS layer built by the ChorOS team at Intuitive Compute. It positions itself as a “cloudless” alternative to AI assistants that send your data to third-party servers. The product is built in approximately 370,000 lines of Rust and ships as a macOS application.

The core promise: your files, notes, meeting recordings, and code become a searchable knowledge graph you can query in natural language — with nothing leaving your machine.

Key claims from the product page:

• Local-first: All data processing happens on-device. No cloud dependency for core features.
• Graph architecture: Files are indexed as structured memory nodes, not flat text.
• Capability-based security: The system controls what data each process or agent can access, inspired by capability security models.
• Delegation to stronger models: For heavy tasks (analysis, drafting), Kora can offload to Claude or GPT-4-class models when you explicitly want it to.
• Supported file types: .md, .txt, .json, .yaml, .csv, .log, .toml, .xml, .html, .pdf, .mp3, .wav, .mp4, .mov.

Setup Workflow

Step 1: Download and Install

Kora ships as a macOS application. Download it from the Intuitive Compute website:

open https://intuitivecompute.com/downloads

No homebrew package detected at time of writing — direct download is the primary install path.

Step 2: Initial Configuration

On first launch, Kora prompts you to:

1. Grant file access permissions for the folders you want indexed
2. Choose your preferred local embedding model (if multiple are available)
3. Optionally connect an external LLM API key for the “borrows a bigger brain” delegation feature

The settings panel lets you control which directories are in the ingestion pipeline (~/kora/ingest/ is the default watch folder).

Step 3: Ingest Your Files

Drop files into the ingest folder or point Kora at an existing directory. The system:

• Chunks documents into semantic units
• Embeds them using a local model
• Stores them as graph nodes with deduplication

~/kora/ingest/
├── notes.md          # 8.2 KB  → processed into memory nodes
├── contracts/        # folder  → recursively indexed
└── recordings/       # audio   → transcribed then indexed

Processed memories show a confidence score (0.0–1.0) indicating how strongly the extracted fact or preference is supported by source material.

Step 4: Query in Natural Language

After ingestion, ask questions via the Kora interface:

"What is the project deadline?"
"Kora: Project deadline is March 15th. (confidence: 0.9)"

Deeper Analysis

Architecture: Graph vs. Vector Store

Most local AI tools use a flat vector embedding store (Chroma, FAISS, etc.). Kora’s graph approach structures memories as nodes with typed relationships — facts, preferences, thoughts. This enables more precise retrieval than pure similarity search, and allows the system to reason about connections between pieces of information.

The capability-based security model is distinct. Where most macOS AI apps run with broad file system access, Kora scopes data access per process — a design borrowed from capability-secure operating system research. This is meaningful for power users concerned about data exfiltration by downstream tools.

The Delegation Feature

Kora can “borrow a bigger brain” by delegating to Claude or ChatGPT for heavy analytical tasks. When enabled, the local context graph is serialized and sent to the external API. This is opt-in per session, not automatic. Sensitive contexts (client contracts, financial data) are flagged as “stays between you and the client” use cases in the product UI.

Privacy Model

The product targets three specific scenarios where local processing matters:

1. Reading client contracts — data never leaves the machine
2. Pulling up financial records — no bank API calls
3. Drafting sensitive documents — no third-party storage

This is a clearer privacy story than vague “your data is secure” claims. The explicit naming of threat vectors is more credible.

Practical Evaluation Checklist

• [ ] Installs cleanly on Apple Silicon and Intel Macs
• [ ] File access permissions requested correctly via macOS TCC
• [ ] Ingestion pipeline handles mixed file types (text, PDF, audio)
• [ ] Query latency is acceptable for local embedding models
• [ ] Capability security actually scopes data access per process
• [ ] External model delegation works with Claude and GPT-4
• [ ] Memory deduplication prevents duplicate nodes on re-ingestion
• [ ] No unexpected outbound connections on fresh install (check with Little Snitch or Radio Silence)

Security Notes

Local-only is not automatically secure. Consider:

• At-rest encryption: Is the on-disk graph encrypted? The product page does not explicitly state disk encryption. If your threat model includes physical access, enable FileVault.
• Memory exposure during delegation: When Kora serializes context and sends it to an external API, that data is subject to the external provider’s privacy policy. Review what context is included before delegating.
• Process isolation: The capability-based security model is promising, but third-party audit or source availability would be needed to verify its implementation. As of this writing, no public security audit is referenced on the site.

FAQ

Q: Does Kora work offline? A: Yes. The core ingestion, embedding, and query pipeline runs entirely offline. The external model delegation feature requires internet access and is opt-in per session.

Q: What embedding model does Kora use locally? A: The product page does not specify the model name. This is an area where official documentation is sparse — confirm with the team before purchasing if local embedding model choice matters for your use case.

Q: Can I self-host the embedding model? A: Kora ships its own local embedding pipeline. It does not appear to expose a config option for swapping in a different model (e.g., a GGUF model via Ollama). Confirm with Intuitive Compute if custom embedding backends are on the roadmap.

Q: How does Kora compare to普通 local RAG tools like LlamaEdge or Ollama? A: Ollama and LlamaEdge are inference runtimes — they run LLMs locally but don’t build a persistent knowledge graph from your files. Kora’s differentiation is the graph-based memory layer and capability security model on top of the file ingestion pipeline. They can be complementary (Ollama for inference, Kora for memory).

Q: Is there a free tier? A: The product page mentions “Get Kora” with a purchase link. A free trial or tier was not clearly documented at time of writing. Check the pricing page directly.

Conclusion

Kora’s strongest angle is privacy-respecting local AI orchestration — turning your files into a queryable memory without cloud dependency. The graph-based architecture and capability security model are technically differentiated from flat vector-store approaches used by most local RAG tools.

The main gap is transparency: no public source code, no security audit, and no clear documentation on the embedding model used. For a security-sensitive product category, this makes independent verification difficult.

If local-first AI memory is a priority and you’re willing to evaluate a closed-source product, Kora is worth a look. Watch for a public security audit or open-source components before treating it as a trust-verified solution.