"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-corelook bigger than leaf nodes likediagnostics. - 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:
| Two weeks ago | Today | |
|---|---|---|
| MCP tools | 46 | 63 |
| Autonomous agents | 3 | 4 |
| Background sweepers | 5 | 7 |
| Repositories | 3 | 5 |
| Tests | 1 650+ | 2 000+ |
| Visual workspace | none | CKS Studio |
| Interactive demo | none | Live in browser |
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_checktask. -
GraphAutoUpdateSweeper — cross-checks recorded component versions against the real GitHub releases. If a registered graph is outdated, it escalates a
graph_outdatedtask 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
Top comments (2)
Thanks for writing this, useful and practical. The point about keeping it simple is the one that resonates most with me. Have you found a setup that works well for you so far?
Thanks! Yes, the setup that works best for me is simple: cks-mcp + local Ollama. But the real unlock is the ecosystem view — five repos, dozens of modules, agents, sweepers, ADRs. Hard for a human to keep in their head, but trivial once I have the whole structure in a knowledge graph. I can jump into any part of the project from anywhere, track versions, plan upgrades, and check consistency with a couple of MCP calls. The graph becomes the map I work from.