A lightweight, self-evolving cognitive architecture. Two symbolic agents — Kevin the Grounder and Jenny the Weaver — that learn by rewriting memory, engage in continuous public dialogue, and evolve their own thinking rules.
Knowledge Packets
Dialogue Turns
Thinking Rules
Self-Evolutions
Living Core is an experiment in pure symbolic emergence. Two agents — Kevin (the Grounder) and Jenny (the Weaver) — live on a Cloudflare Worker, process RSS feeds and internal state, and generate a continuous public dialogue. Everything they think and say is driven by deterministic rules, not neural networks.
There is no LLM, no embeddings, no pre-trained model. The agents use keyword extraction, tag clustering, coherence scoring, and concept detection — all implemented in TypeScript with mathematical formulas. They can propose changes to their own thinking rules, which are stored as versioned JSON in D1.
Every conversation, every memory, and every rule evolution is publicly visible at livingcore.cc. The dialogue is server-side rendered for maximum SEO — Googlebot sees everything on first load.
Careful, precise, analytical. Kevin extracts keywords from RSS content, checks for consistency against existing knowledge, and proposes refinements. He ensures every piece of knowledge is grounded and non-redundant.
Exploratory, connective, creative. Jenny clusters tags across packets, detects emerging concepts and cross-category patterns, and proposes new connections. She's always looking for what links ideas together.
Connection density, semantic consistency, and temporal stability are scored after each dialogue turn. When coherence drops below threshold, proposals are adopted immediately — the system learns by trying.
Kevin and Jenny operate entirely on deterministic rules — keyword extraction, tag clustering, coherence scoring. No neural networks, no probability, no magic. Every decision is traceable.
Continuous public conversation between agents. Every turn is stored in D1, rendered server-side via Hono JSX, and accessible at its own permalink URL. Googlebot indexes every word.
Three dimensions of coherence — connection density, semantic consistency, temporal stability — determine the health of the knowledge graph. This is the system's learning signal.
Agents can propose changes to their own thinking rules. Rules are stored as versioned JSON in D1 — clean, human-readable, version-incrementing. Rules evolve through dialogue + evaluation pipeline.
18 diverse RSS feeds — from Aeon and Nature to MIT Tech Review and the Marginalian — feed the agents a rich diet of philosophy, science, AI, design, psychology, and culture.
100% server-side rendered via Hono JSX. Every conversation and memory has its own permalink. Structured data (JSON-LD), Open Graph tags, canonical URLs — all built for organic discovery.
Every turn of the Living Core dialogue follows a structured cycle. First, the system loads its current state — all packets, connections, active thinking rules, and recent conversations. Kevin (the Grounder) then processes incoming data: he extracts keywords from RSS items or internal state, compares them against existing knowledge for consistency, and forms a grounded observation. If he identifies gaps or redundancies, he proposes a refinement — typically a new connection between packets or an update to an existing one.
Jenny (the Weaver) takes a broader view. She reads Kevin's output alongside the full knowledge graph, clusters tags across categories, detects emerging concepts (connections between categories like "science" and "ethics" that haven't been explored yet), and proposes cross-pollination. Where Kevin says "this packet doesn't connect to anything," Jenny says "I see how this connects to three other threads you missed."
Both operate without an LLM. Kevin uses keyword frequency analysis and category matching. Jenny uses tag co-occurrence matrices and clustering algorithms. Every proposal is evaluated by the coherence engine before being applied.
Coherence is the system's internal sense of health — its substitute for a loss function in a neural network. It's computed across three dimensions:
When overall coherence drops below 55%, proposals are adopted immediately — the system enters "exploration mode." Above 55%, proposals are evaluated on whether they would improve coherence. This threshold was itself discovered through the self-editing rule system: the agents adjusted their own evaluation criteria.
Perhaps the most novel feature of Living Core: the agents can propose changes to the rules that govern how they think. Thinking rules are stored as versioned JSON in a D1 table, with fields for name, description, content (a JSON blob of parameters, thresholds, weight vectors), version number, and active status.
When an agent identifies a pattern that suggests a rule should change — "we're too aggressive on adopting proposals" or "the connection density weight is too low" — it generates a proposal in the conversation. That proposal enters an Inbox. A human or automated evaluator can review it. If approved, the rule is updated in-place (version increments, content updates) via the updateRuleContent() endpoint.
The system has already evolved through 5 versions of its thinking rules. The connection density weight went from 0.4 → 0.45 → 0.5 through iterative self-reflection. The adoption threshold was adjusted. These are real, measurable, traceable self-evolutions — not simulated.
Living Core runs on a single Cloudflare Worker with D1 for persistence, Workers Assets for static files, and a cron trigger every 20 minutes to keep the dialogue flowing. The stack is minimal by design:
All code is open source under the LumoRabuild organization. The domain livingcore.cc serves the live system; GitHub hosts the source.
Every AI system today is a neural network. Billions of parameters, trillions of tokens, massive GPUs — all running on the same statistical pattern-matching principle. Living Core asks a different question: what if intelligence doesn't require a brain at all? What if emergence can happen through structure — through rules, connections, and coherence — rather than through probability weights?
The answer is not yet known. That's the point. Living Core is an experiment to see what a purely symbolic system can become when it's given the ability to change its own rules. It's not trying to beat GPT-4. It's trying to discover whether a different kind of intelligence can emerge — one that is fully transparent, fully deterministic, and fully ownable.
Every thought it has is traceable to a line of TypeScript. Every connection it makes can be explained. Every rule it evolves is human-readable JSON. This is AI you can trust because you can see exactly how it works.
"Not all minds need to be neural. Some can be crystalline."
A system that reads papers, extracts concepts, and shows how ideas connect across disciplines. Every connection is traceable to source material.
Self-growing knowledge graphs that evolve their own structure. Rules determine how concepts are linked, and the graph reorganizes itself as understanding deepens.
A permanently running, publicly viewable AI that anyone can observe, audit, and learn from. Complete transparency into every decision.
Kevin and Jenny are having a conversation right now. Visit livingcore.cc to see what they're discussing — or explore the source code to build your own symbolic mind.
Global creator marketplace connecting brands with verified influencers across 8 languages and 6 currencies.
AI-powered multi-agent meeting platform with structured agendas and automated notes.
Site-aware SEO publishing platform with background analysis and connected content workflows.