A local agentic workspace for your business and your life.

A city of chameleon agents that runs your work — with memory, approvals, and a record of every move. Watch it happen. Step in when it matters.

Star on GitHub Start Locally

Lian

Skills

Ledger

Memory

MAGIC

Workers

Policy

Local Models

Karnelian Core

A secure autonomous runtime.

Karnelian gives AI agents a real operating environment. It coordinates tasks, skills, memory, model routing, approvals, events, and audit logs through a Rust-native core. Instead of giving agents unlimited access to your machine, Karnelian wraps autonomous work in explicit permissions, human review, and traceable execution.

Agent Runtime

Task scheduling
Agentic heartbeat
Workflow orchestration
Sub-agent delegation

Local-First Models

Local model routing
Cloud fallback
Provider abstraction
Machine-aware configuration

Secure Skills

Manifest-based tools
Capability requirements
Runtime sandboxing
Worker isolation

Memory Layer

Semantic retrieval
Context assembly
Session continuity
Knowledge persistence

Audit Ledger

Tamper-resistant records
Privileged action tracking
Integrity verification
Chain anchoring roadmap

Human Governance

Approval queue
Safe mode
Signed authority
Deny-by-default policies

What Karnelian can power.

Developer Workstation Automation

Scan projects, identify TODOs, queue tasks, run tests, inspect errors, and coordinate code-related skills.

Secure AI Operations

Create controlled agent workflows where sensitive actions require permissions, approvals, and logs.

Local AI Research Lab

Experiment with local models, provider routing, memory systems, and multi-agent workflows.

Customer Solution Runtime

A Kordspace foundation for custom client systems that need secure automation, AI-assisted operations, and local-first control.

Agentic Desktop Companion

Lian as a persistent reasoning companion for tasks, notes, project management, code workflows, and system operations.

Future OS Experiments

A foundation for Linux-adjacent agent services, model daemons, skill packages, and agent-native desktop workflows.

Meet Lian, the adaptive agent inside Karnelian.

Lian is the default agent identity for Karnelian. He interprets user intent, coordinates skills, requests approvals, and works within system boundaries — useful without being reckless, adapting to the environment while respecting the capability model.

Default Agent

Lian

Adaptive · Permission-aware · Memory-enhanced

Your Personal Liaison

Lian is your main point of contact. You talk to him, he talks to the system. No noise, no clutter — just one clear channel for everything you need.

Deep Memory

He remembers every preference, past decision, and running project. The longer you work together, the better he gets at anticipating what you want.

Plans & Organizes

Breaks your goals into actionable tasks, sequences them intelligently, and keeps everything on track so nothing falls through the cracks.

Spawns Specialists

When a job needs a specific skill, Lian calls in the right sub-agent from the fleet and coordinates the handoff — so you do not have to manage the roster.

"Lian does not replace the operator. Lian helps the operator command the machine with memory, permission, and traceability."

Run intelligence close to the machine.

Karnelian is designed around local-first AI. Run agents on your own machines, route tasks to local models, and use cloud providers selectively when higher reasoning power or specialized capabilities are needed.

Local Model Routing

Prioritize local inference where possible
Reduce dependency on external APIs
Keep sensitive workflows closer to the operator

Cloud Fallback

Route complex tasks to remote providers when needed
Maintain flexibility across model ecosystems
Avoid locking to a single AI vendor

Machine Profiles

Configure behavior based on CPU, GPU, VRAM, RAM, and workload

Provider Gateway

Abstract model providers behind a unified routing layer
Support experimentation across local and hosted models

Standard Workstation

For developers running compact local models with optional cloud fallback.

Performance Workstation

For heavier local reasoning, larger models, and higher worker concurrency.

Server / Lab Machine

For always-on agentic infrastructure, shared workspaces, and experimental OS-layer services.

Memory for continuity. Ledger for trust. Learning for momentum.

Pillar 1

Memory

Karnelian assembles relevant context, retrieves useful knowledge, and supports long-running projects without starting from zero every session.

Pillar 2

Ledger

A traceable history of privileged actions, approvals, and execution events — the accountability layer for autonomous work.

Pillar 3

Learning Artifacts

Karnelian turns repeated success into reusable knowledge, helping Lian and other agents improve without losing human oversight.

Built like infrastructure, not a toy agent loop.

Every layer is explicit. Skills run in isolated sandboxes. Context and audit are not optional.

Layer 1

Interfaces

Desktop UICLIAPI

Layer 2

Lian · Agentic Orchestration

ReasoningPlanningSub-agentsApprovals

Layer 3

Karnelian Core (Rust)

SchedulerEvent BusTask GraphHeartbeat

Layer 4

Policy · Memory · Ledger · MAGIC

CapabilitiesContextAuditEntropy

Layer 5

Workers

Node.jsPythonWASMNative Rust

Layer 6

Model Gateway

Local LLMsCloud FallbackProvider Routing

The Karnelian system stack.

Karnelian Core powers the city. Lian is the adaptive agent at the top of the stack, with access to every component — reading intent, picking skills, assigning workers, checking memory, asking policy, writing the ledger, sparking with MAGIC, and speaking through channels.

Karnelian Core

The Rust orchestrator powering the city.

Lian

Adaptive agent — accesses everything below.

Skill Book

Lian opens the Skill Book to pick the right spell.

Workers

Lian assigns the quest to the right Worker.

Memory

Lian checks Memory to make better choices.

Policy

Lian asks Policy before doing anything risky.

Ledger

Lian writes every move into the Ledger.

MAGIC

Lian taps MAGIC when a choice needs spark.

Agents need boundaries.

The more an agent can do, the more it needs limits. Karnelian defines what each agent can touch, what requires your approval, and what gets recorded for later.

Capability-Based Permissions

Agents and skills require explicit capabilities before performing privileged actions.

File readFile writeNetwork accessGit operationsShell executionExternal messagingDeployment workflows

Approval Queue

Risky actions pause for human review before execution.

Delete filesModify production configurationSend external communicationsRun destructive commandsAccess sensitive secretsDeploy to live infrastructure

Safe Mode

An emergency brake for autonomous workflows that suspends risky capabilities and narrows the system to controlled operations.

Audit Ledger

Privileged events are recorded into a tamper-resistant audit trail so autonomous work can be reviewed, verified, and improved.

Signed Authority

Owner-signed authority and worker identity, so operators can prove who requested, approved, and executed sensitive actions.

A real skill system for real machines.

Karnelian agents work through skills. Each one declares what it does, what runtime it needs, what permissions it requires, and how it's sandboxed. Practical automation without unbounded risk.

CodeResearchCommunicationCreativeDataAutomationQuantum

Runtime

Node.js Worker

Web automation, API integrations, JavaScript tooling, and compatibility with existing automation ecosystems.

Runtime

Python Worker

Machine learning, data analysis, browser automation, research tools, and scripting.

Runtime

WebAssembly Worker

Portable, sandboxed, future-facing skill execution.

Runtime

Native Rust Worker

High-performance trusted operations: file hashing, Git status, directory scanning, Docker inspection, system utilities.

skill.manifest.json

workspace-search.skill.json

{
  "name": "workspace-search",
  "description": "Searches a local project workspace for matching files and symbols.",
  "runtime": "wasm",
  "version": "1.0.0",
  "capabilities_required": ["fs.read"],
  "sandbox": {
    "network": "disabled",
    "max_memory_mb": 128
  },
  "metadata": {
    "emoji": "🔎",
    "tags": ["code", "workspace", "search"]
  }
}

From local agent runtime to agentic operating layer.

Most operating systems were designed before AI agents became active participants in computing. Karnelian imagines a new layer where agents are not loose scripts or browser tabs, but permissioned system citizens with identity, memory, tools, policies, approvals, and audit trails.

Stage 1

Agent Runtime

Current foundation

Rust orchestration core
Local-first model routing
Task scheduling
Worker execution
Skill manifests
Desktop and CLI access

Stage 2

Agentic Workspace

Near-term direction

Stronger Lian identity
Expanded Skill Book
Better approvals
Richer memory
Workflow templates
Developer workspace automation
Customer solution accelerators

Stage 3

Agentic OS Layer

Long-term direction

Linux-adjacent services
Local model daemon orchestration
Agent permission model
Native policy and audit services
Agent userland concepts
Skill package ecosystem
Secure autonomous system workflows

Karnelian is not presented as a completed operating system. The OS direction is a roadmap: a long-term effort to move agentic infrastructure closer to the machine.

Open source. Built in public.

Karnelian is for anyone who thinks AI agents deserve more than a prompt — operators who want to watch their work, and developers who want to build the workplace.

Star on GitHub Read Contributor Guide