From Platform to Ecosystem: CKS Now Has a Visual Brain — and a Demo You Can Play With

"Two weeks ago, CKS learned to manage knowledge autonomously. Now it has a face: a visual workspace, a live demo, and an ecosystem that can explain itself — in 2D, 3D, and plain English."

A week ago, I wrote about how CKS evolved from a validator into a self-maintaining knowledge platform: sweepers detected staleness, autonomous agents resolved conflicts, and a knowledge graph of our own ecosystem caught real bugs in its design.

That was the invisible machinery. What was missing was a human window into the system.

Today, that window exists. We shipped CKS Studio, a React-based visual workspace, and CKS Website, a documentation site with an interactive demo that runs entirely in your browser — no server, no API keys, no setup.

And with that, CKS stopped being a backend platform. It became an ecosystem.

The visual layer: CKS Studio

CKS Studio is a thin frontend over cks-mcp. It doesn't hold any knowledge itself — it talks to the MCP server over HTTP. But it makes the knowledge graph visible and operable.

Here's what you can do:

• Explore graphs in 2D or 3D — the same session can be viewed as a clean Dagre layout or as a force-directed 3D graph. 3D nodes now render as cards, sized by how connected they are. Hub nodes like cks-core look bigger than leaf nodes like diagnostics.
• Search instantly — Cmd/Ctrl+K opens a fuzzy search over every node. No more hunting for a single object in a dense graph.
• Chat with your graph — the AI Chat panel lets you ask questions about the session, call MCP tools, and mutate the graph. Works with Ollama, Anthropic, or any OpenAI-compatible provider.
• Monitor agents — the Agent Panel shows the status of all seven in-process sweepers and four standalone agents. Start, stop, and request graceful shutdown directly from the UI.
• Review version diffs — compare the current session state with any previous version, with color-coded object and relation changes.
• Browse the gallery — public knowledge graphs saved via Memory Agent, with lazy health scores.
• Install as a desktop app — PWA support means you can add it to your dock and work offline.

All of it is connected to the same cks-mcp tools that LLMs use. The UI never does anything the MCP tools can't do — it's just the human-accessible surface of the same system.

The demo: no server required

The docs site now embeds a static demo of CKS Studio, preloaded with the full CKS ecosystem graph — 277 objects and 158 relations across five repositories.

You can:

• Switch between 2D and 3D views
• Zoom, pan, search, filter by type
• Open the Gallery, Agents, Chat, and Settings tabs (mock data where a live server would be needed)
• Toggle light/dark theme

It's the fastest way to understand what CKS feels like as a user.

🎮 Try it here:

https://deus-corp.github.io/cks-website/demo/

The self-maintaining machine, updated

While we were building the UI, the autonomous core kept evolving. The numbers moved again since last week:

The two new sweepers are worth mentioning:

• GraphHealthSweeper — computes a 0.0–1.0 health score for every registered graph, combining freshness, contradiction count, verification coverage, and dead-lettered conflict tasks. If a graph scores below 0.7, it escalates a health_check task.
• GraphAutoUpdateSweeper — cross-checks recorded component versions against the real GitHub releases. If a registered graph is outdated, it escalates a graph_outdated task so the Memory Agent can update it.

And the fourth agent, ForkResolutionAgent, closes the CRDT loop. When concurrent replicas produce a fork, this agent resolves it mechanically — preferring the causally-newest object, falling back to recency, then a deterministic tiebreak. No LLM needed.

Phase 1 safety: autonomous, but not reckless

With more autonomy comes more risk. So we added Phase 1 safety infrastructure:

• Automatic fork sandboxing — pipeline runs can be isolated so they never touch the parent session directly.
• Token budgeting — LLM calls get a budget, not an open tab.
• Idempotency cache — identical pipeline runs are deduplicated by content hash.
• Graceful degradation — if a step fails, the run stops cleanly and leaves the sandbox for manual analysis.

It's a small step toward making autonomous agents genuinely safe, not just impressive.

We keep testing on ourselves

This week, we built a knowledge graph of our own ecosystem — not just the repos, but the studio, the website, the demo, the sweepers, the agents, the tools, the ADRs, the storage backends.

Then we asked Claude, via cks-mcp, to update that graph using its own tools. It called get_graph, inspected the structure, and applied 11 evolve_knowledge operations in one shot: version bumps, milestone updates, new source-file pointers.

The result? The graph now reflects reality again — and we didn't hand-edit a single line.

The system is not just describing itself. It's maintaining its own documentation graph.

Why the visual layer matters

Language models are good at producing plausible answers. But trust is a human experience.

If a user can't see how a conclusion was reached, browse the evidence, watch an agent resolve a conflict, or compare two versions, then even a perfectly auditable backend feels like a black box.

CKS Studio and the live demo close that gap. They make verifiable knowledge tangible.

"CKS stopped being something you call. It became something you can watch — and now, something you can touch."

GitHub: Deus-corp/cks-mcp · Docs: deus-corp.github.io/cks-website · Interactive demo: deus-corp.github.io/cks-website/demo/ · PyPI: cks-mcp