Author: Dr. Mani

In Daedalus, ThoughtSeeds and regular hypotheses operate at very different levels of the research process:
Scale and Dynamism: A regular hypothesis represents the overarching scientific proposition being tested by the mock study
. It is defined and frozen in the study packet before the run begins
and is formally evaluated in the final scientific report
. In contrast, ThoughtSeeds are “small candidate ideas or working hypotheses”
. Rather than remaining static throughout a study, they are highly dynamic elements that “can be activated, compared, developed, or suppressed as a system works through a problem”
.
Operational Purpose: While a regular hypothesis is the subject of the formal scientific investigation
, ThoughtSeeds are “engineering and research constructs”
. They are designed to help researchers study the internal mechanics of the AI itself—specifically to observe memory, attention, coordination, and how ideas develop inside the artificial system
.
Visibility in Reports: The primary scientific hypothesis is a public-facing component that must be clearly outlined in both the Daedalus primary study report
and the final public journal article
. ThoughtSeeds, however, represent the sub-symbolic, internal coordination of the system as it works, acting alongside functional global-workspace architectures to manage the system’s memory and attention
.

Status: development-study design. This is a testable proposal, not a result. It belongs in a new study beside Stage 2b and cannot change the completed Stage 2b contract.

When Kavi, Friedman, and Patow released their new Thoughtseeds paper on July 16, 2026, I recognized the name before I understood the machine.

We already had a ThoughtSeedDTO running inside our own software. Their paper had thoughtseeds too. It would have been easy to assume that both teams had built different versions of the same object.

Then we compared the models.

Their thoughtseed was built to infer a hidden state inside changing network activity. Ours was built so an agent system could identify a candidate thought, watch it compete, and preserve what happened to it.

That difference did not ruin the connection. It gave us an experiment.

One name. Two instruments. One test neither could run alone.

We did not invent the word

The shared name came from the same scientific neighborhood: active inference, competing contents, nested organization, and the question of how a coherent thought can guide attention and action.

The exact family tree still needs care. Kavi and colleagues described their 2024 Thoughtseeds Framework as novel. Our package’s NOTICE credits an in-preparation ThoughtSeed Hypothesis by Ruben Laukkonen and Shamil Chandaria, along with IWMT, Global Workspace Theory, and active inference. Our specific Pydantic models, competition rule, child spawning, and workspace machinery were implemented by us, but the underlying word and theoretical territory were not our invention.

Those provenance statements are not yet reconciled in the primary literature. I would rather show that seam than write a cleaner origin story than the evidence allows.

What we can verify is simpler: the two implementations inherited a related intuition, then made it concrete for different jobs.

What our ThoughtSeed was built to do

We began the package work on May 19, 2026, and extracted it into a standalone runtime on June 10. Both happened before the new latent-cause paper appeared, though well after Kavi’s earlier Thoughtseeds work.

Our problem was an agent-runtime problem. Several candidate pieces of content might be active at once. We needed a way to keep each candidate addressable while it competed: what it contained, where it came from, how strongly it was activated, whether it won or lost, what parent it came from, and which attractor basin might organize its return.

That is why our ThoughtSeedDTO has an identity and a lifecycle. Its activation is continuous, so calling it merely a “discrete thoughtseed” misses the important point. The object itself is discrete and addressable. It can be pointed to again.

In the current Dionysus adapter, a retrieved candidate bridge becomes a conceptual ThoughtSeed. The candidates compete, and the lifecycle is emitted for the builder to inspect. The user-facing answer remains byte-for-byte identical with the Thoughtseed layer on or off. Right now, this is an observability instrument. It lets us see which candidate won without quietly letting that instrument write the reply it is supposed to measure.

Think of the full runtime object as a passport for a candidate thought. It can carry identity, origin, status, and lineage, although the current Dionysus adapter exposes only the smaller observability slice: identity, content, activation, and lifecycle events.

What their Thoughtseed was built to do

The 2026 paper asks a different question: can a small learned state capture the mental structure hiding inside a changing physiological process?

Its Layer 1 is a tractable four-network model of brain dynamics. Layer 2 maintains a five-dimensional latent vector with named coordinates such as attention to breath, pain or discomfort, pending tasks, an “aha” moment, and equanimity. An encoder, decoder, and forward model learn how that latent state relates to network activity and what may happen next. Layer 3 then combines policy evidence with habit and dwell-time priors, using meta-awareness as part of a proposed Global Neuronal Workspace gate.

This thoughtseed is not primarily a record of one candidate’s biography. It is a learned state estimate. Its value lies in reconstruction, prediction, and intervention: does the compact latent state explain the changing process, help forecast the next transition, or let a metacognitive layer regulate what happens next?

The authors ran one 12,000-step simulation for an expert phenotype and one for a novice phenotype. The final parameters are still theoretically motivated and need empirical calibration. That makes the model a serious piece of computational phenomenology, not evidence that the simulation is conscious.

The mismatch creates the question

Now we can ask something neither implementation could answer by looking only at itself:

Which predicts the next winning content better, a learned hidden state or the explicit history of the candidates that competed?

That is the experiment.

Use the same held-out sequences and ask each representation to predict which content becomes broadly available next, how long it remains stable, and what transition follows. Give the comparison three real competitors:

• a simple baseline built from raw activations and ordinary output measures;
• a Kavi-style learned latent state;
• our addressable candidate model with activation, outcome, lineage, provenance, and basin linkage.

J-space gives us a candidate internal readout of workspace-like availability. Behavior gives us the external check. A representation should not win because it describes the labels we used to build it. It should win because it predicts held-out events and survives an intervention designed to make it fail.

If the learned latent state beats both the simple baseline and candidate history, then compact hidden structure is doing real work. If candidate history adds prediction after the latent state is known, then identity and lineage carry information the compressed state leaves behind. If a later adapter adds held-out predictive value after we match model capacity and control for overfitting, then we have evidence that the two representations are complementary.

And if neither beats the simple baseline, “thoughtseed” may be carrying more intuition than explanatory power in this setting. That result would be useful too.

Which instrument should we use?

The question chooses the instrument.

If we want to know what hidden state best explains changing network dynamics, we use the learned latent model.

If we need to know which explicit candidate appeared, where it came from, what beat it, and whether it returns, we use the addressable runtime object.

If we want to know whether those are two views of the same process, we connect them with an adapter only after each has faced the same baselines on its own. Merging them first would erase the comparison. A positive result would become impossible to assign: did the learned state help, did candidate history help, or did one representation quietly define the other?

This is why the mismatch matters. It keeps the question answerable.

What we do next

The next move is a CPU-first reproduction and clean-room interface study with frozen comparisons, held-out data, interventions, and stop conditions. It remains separate from Stage 2b.

There is also a code boundary. As of August 3, 2026, GitHub does not report a license for prakash-kavi/thoughtseeds_model. Public source is readable source, not automatic permission to copy or redistribute it. We can reproduce the published scientific contract and ask the authors about licensing before reusing their implementation.

No consciousness claim is on the table. Even a strong result would support a narrower statement: one representation predicts and changes a measurable process of availability better than its alternatives.

That is enough. In a field full of names that can outrun their evidence, one clean comparison is more valuable than a premature grand theory.

Validation trail

• Current paper: Kavi, P. C., Friedman, D. A., and Patow, G. (2026), Thoughtseeds as Latent Causes.
• Current reference implementation: prakash-kavi/thoughtseeds_model.
• Earlier architecture: Kavi, P. C., Zamora-López, G., and Friedman, D. A. (2024), From Neuronal Packets to Thoughtseeds.
• Peer-reviewed framework: Kavi, P. C., Zamora-López, G., Friedman, D. A., and Patow, G. (2025), Thoughtseeds.
• Our runtime: thoughtseed-runtime v0.1.0, Apache-2.0, authored by Mani Saint-Victor, MD. Public evidence receipt pending.
• Proposed comparison: a new disjoint development study, not Stage 2b.

APA reference: Kavi, P. C., Friedman, D. A., & Patow, G. (2026). Thoughtseeds as latent causes: A dual-process computational phenomenology of focused-attention meditation. arXiv. https://doi.org/10.48550/arXiv.2607.14833

There is a dangerous elegance to asking an old AI system where it came from.

It may produce a coherent family history. It may recognize familiar names, recover old design language, and explain how one component became another.

Coherence is not ancestry.

That is the question behind our next reconstruction study: Can a frozen early scientific system help recover its own ancestry without being allowed to invent that ancestry?

Let the system remember. Make the evidence decide.

The system is both witness and suspect

Dionysus may contain traces of its own history: orchestration decisions, autobiographical continuity, retrieval patterns, and early assumptions about how experience should change future behavior.

Those traces could help us find what mattered. They cannot certify themselves.

A system asked to explain its own origin faces the same problem any witness does. Memory can guide an investigation, but memory also compresses, fills gaps, and builds a story around what remains. With an AI system, there is an added danger: a fluent account can make unsupported ancestry feel implemented.

So we are separating two jobs that are easy to collapse.

Dionysus and Daedalus may propose what the ancestral system was trying to become. Archimedes must independently check those proposals against code, tests, runtime evidence, and complete trial history. I retain the human-only job: deciding what the evidence means for our priorities and whether any reconstructed claim is accepted.

That separation is not bureaucracy. It is the experiment.

The nine-stage loop we are trying to recover

The reconstruction centers on a simple idea: an event should be able to change what the system does later.

To test that idea, we are tracing a nine-stage loop:

1. An event enters the system.
2. The system forms an episode from it.
3. The episode becomes part of autobiographical memory.
4. Repeated or important experience is consolidated.
5. Consolidation contributes to semantic knowledge.
6. The system extracts or updates a reusable procedure.
7. A later situation retrieves the relevant context.
8. That retrieved context changes orchestration or action.
9. The outcome returns as feedback for the next cycle.

The loop sounds plausible. Plausibility is cheap.

For every stage, the research has to ask a harder question: Is this implemented and reachable, or merely named? Does a meaningful test fail when the feature is disabled? Is the apparent memory a stored episode, a replayed prompt, a static template, a mock, or a real influence on later behavior?

The distinction that matters most is between having a record and being changed by it.

A database row proves storage. A retrieved paragraph proves retrieval. Neither one proves learning.

Four roles, four kinds of authority

The working division of labor gives each system a different responsibility.

Dionysus is the candidate continuity layer. Its proposed role is orchestration, autobiographical memory, and bringing past context into a future episode.

Daedalus is the scientific builder. In the proposed study, it is assigned intake, hypothesis development, experiment generation, and exploration of procedural improvement.

Archimedes is the independent lab authority. It reviews evidence, challenges ancestry claims, protects experimental boundaries, and determines whether an execution is scientifically admissible.

I remain responsible for meaning and ratification. The systems can organize evidence and propose interpretations. They cannot decide what becomes accepted history simply because the story is elegant.

These roles matter because self-reconstruction becomes circular the moment one agent proposes the lineage, grades the lineage, selects the supporting evidence, and declares itself improved.

What would count as actual learning?

The cleanest test is not whether the reconstructed system can describe an earlier episode. It is whether information from that episode changes behavior later, under conditions that rule out simpler explanations.

Imagine two matched later episodes. One system receives a verified memory produced during an earlier episode. The control system receives either no memory, a neutral record, or the same information as plain prompt replay. Both face the same frozen task, tools, and scoring rules.

If the memory-conditioned system makes a better decision, we still have work to do. We must show that the advantage came from the intended memory pathway rather than extra tokens, a static template, hidden labels, evaluator leakage, or a permissive test.

The feature should also fail when the relevant component is disabled or made unreachable. A test that passes either way is not evidence of function. It is decoration with an assertion count.

The first experiment should be smaller than the story

The largest question is whether a verified reconstruction can outperform its frozen seed. That is too broad for the first run.

The highest-value first experiment is narrower: Can one verified episode produce a measurable, attributable change in one later decision?

The treatment receives the earlier episode through the reconstructed memory path. The controls receive no episode, prompt replay, and a complexity-matched neutral episode. The unit of analysis is one frozen earlier-later episode pair. Inputs, code snapshot, evaluator, scoring rule, and privacy allowlist are fixed before the run.

The evaluation borrows Fable’s integrity discipline: adversarial counterexamples, privacy allowlists, human-only gates, and tests that fail when a feature is disabled or unreachable.

PASS requires one complete, unchanged snapshot of the source, dependencies, configuration, and test inventory. Missing, skipped, stale, flaky, or mixed-snapshot evidence remains non-PASS. For critical model-backed behavior, we retain the complete trial history and require the latest three consecutive same-snapshot attempts.

Success requires more than a higher average score. The change must appear across a preregistered trial history, survive adversarial counterexamples, disappear when the memory pathway is disabled, and remain absent when only the narrative language is preserved.

The study stops if private autobiographical material crosses the allowlist, if the treatment sees evaluation labels, if Archimedes and the candidate reconstruction share evidence they were meant to hold separately, or if a human-only approval gate is bypassed.

Only after that result survives should we ask whether procedural learning improves repeated performance, whether independently recovered components reconstruct the intended ancestry accurately, and whether the reconstructed system beats its frozen seed on held-out work.

What this can teach us even if it fails

Failure would still separate several ideas that are often bundled together.

We may find a durable archive that does not change behavior. We may find retrieval without learning. We may find convincing ancestry stories with no code-level match. We may find that independent validation blocks the most appealing reconstructions because their evidence is circular.

Those are useful results. They tell us where continuity ends and narrative begins.

And there is a harder possibility. The system may recover part of its working ancestry, survive an evaluator designed to disprove it, carry one verified lesson into a later episode, and eventually improve beyond its seed.

That would not show that the system is conscious. It would show something narrower and testable: a scientific system can use preserved experience to reconstruct a functional part of its past, then use that verified reconstruction to change what it does next.

Let the system remember. Make the evidence decide.

The live question is not whether the descendants can tell us a beautiful origin story. It is whether the story still holds when the code, the controls, and an independent evaluator are allowed to say no.

Research boundary

This post describes a proposed research program, not completed findings. Existing reports, system names, and Dr. Mani’s first-person account are provenance to investigate. They are not proof of implementation or ancestry. Any later claim will be separated into verified implementation, runtime evidence, supported inference, hypothesis, speculation, or mythos.

Why the last mile of AI memory repair is not cleanup. It is judgment.

At the end of the first repair, the audit landed on seven.

Twenty-six memory stores. One hundred eighty-five active files. No orphaned active memories. No broken index entries.

Seven unresolved wikilinks.

The tempting move was obvious.

Create seven missing files. Change seven links. Get the green check. Go home.

Clean.

Also potentially wrong seven different ways.

Because a broken memory link tells you exactly one thing:

The link is broken.

It does not tell you what the memory should become.

A broken link is a question, not an instruction.

So instead of bulk cleanup, we built an adjudication harness. Every memory gets evidence, an independent challenge, and a rollback path before it moves an inch.

The link that looked easy

One unresolved link was [[mani-voice]].

That sounds like a missing file.

Just create mani-voice.md, right?

Except there was already a canonical voice corpus. There were project-specific writing rules. There were runtime instructions. There were stable user preferences that had just been canonicalized across Claude, Codex, and Hermes.

Creating another file would fix the link by rebuilding the duplication problem we had just spent days removing.

So maybe the link should point to the voice corpus.

Unless the project memory system cannot retrieve that cross-store target.

Maybe it should point to the canonical user rule.

Unless the source record is about writing procedure, not user preference.

Maybe it should become plain text because it was never supposed to be a link.

Every option makes the scanner happy.

Every option creates a different system.

The scanner cannot choose because the scanner does not know what mani-voice owns.

It can beep.

It cannot tell you whether it found a coin, a pipe, or a land mine.

That is where cleanup stops being mechanical.

Clean is not correct

Most cleanup logic is built from signals that are easy to count.

Old file. Archive it.

Unindexed file. Add it.

Duplicate text. Merge it.

Broken link. Replace it.

Stale claim. Delete it.

Beautiful report.

Potentially disastrous memory.

An old incident may explain a current safeguard. An unindexed file may be intentionally quarantined. Two similar records may belong to different profiles. A procedure may deserve a tested skill instead of a longer paragraph. A stale installation claim may need to become dated history because the sequence of what broke and what fixed it still matters.

The filename does not know that.

The modification date does not know that.

The index does not know that.

Clean is not correct.

A system can have zero broken links and still feed the agent obsolete claims, misplaced rules, and polished little lies.

That is worse than a visible broken link.

At least the broken link admits there is a question.

Every memory gets a case

The solution is slower than bulk cleanup.

It is faster than recovering from a bad one.

Each unresolved memory, or inseparable cluster of conflicting memories, gets a case ID.

The case includes the complete record. Not the filename. Not the opening paragraph. Not the one-line index summary.

The whole damn thing.

Frontmatter. Backlinks. Conflicts. Possible destinations. Current evidence. Retrieval path. Every factual claim that could disappear during a tidy little merge.

Then the work separates.

A coordinator reserves the source and destination stores so two workers cannot edit the same index or collide during a cross-store move.

A researcher separates durable facts from dated history, volatile state, procedure, instruction, sensitive material, and claims nobody can currently prove.

Then the researcher has to propose more than one outcome.

Keep it. Correct it. Split it. Merge it. Move it. Preserve the incident as history. Turn the volatile part into a live verification command. Point across stores. Recommend a skill. Quarantine the thing until the evidence catches up.

Or do something custom because the memory refuses to fit the boxes.

The categories serve the memory.

The memory does not serve the categories.

Then an independent evaluator tries to kill the recommendation.

That part matters.

The person who fell in love with a clever reorganization should not be the only person deciding whether it loses information.

Is the proposed owner correct? Is the evidence current? Did the researcher search the destination for collisions? Will the right sessions still retrieve the record? Is a project rule about to leak into every profile? Is a resolved incident being erased because closed looked the same as useless?

The evaluator returns one of four answers: pass, revise, blocked, or no change.

No pass, no mutation.

Only then does the implementer touch the file.

One logical case at a time. Original bytes preserved. Quarantine instead of deletion. Indexes updated. Backlinks checked. Retrieval tested. Rollback proved.

Seven links.

Seven evidence trails.

Seven reversible decisions.

Not seven reflexes.

A green check has to earn the right to be trusted

There is one more problem.

What if the harness approves everything because the harness is blind?

So before it touches live memory, it gets planted cases.

A clear keep. A real move. A mixed record that must split. A stale claim that needs correction. A genuine duplicate. A resolved incident that must remain history. A procedure that belongs in a skill. A protected instruction that requires approval. A sensitive record that must stop the workflow. A weird case where every standard answer is wrong.

The evaluator has to call each one correctly.

Every scanner that claims zero hits has to detect a planted hit first.

A green check counts only after a red check works.

That rule would have prevented the first false-clean audit, when a shell loop mishandled project paths and the scanner treated TOML inside a code fence like a missing memory.

The check was green.

The checker was wrong.

Now the checker has to prove it can fail.

What this changes when an agent answers you

The first tier made the agents remember me consistently.

This tier helps them remember reality consistently.

Fewer contradictions between related project memories. Fewer dead references. Less obsolete runtime state presented as current. Less project information leaking into the wrong profile. Better preservation of why a decision was made. Fewer procedures duplicated as prose.

And when something is history, the system can say it is history without pretending it never happened.

That matters because memory has to answer more than What is true?

It also has to answer:

Why did we decide this?

What did it replace?

Who needs to know it?

What breaks if we undo it?

Delete the wrong old memory and the next agent gets to relearn the lesson with fresh damage.

Preserve everything indiscriminately and the agent has to fight through every version before it can act.

The job is neither hoarding nor cleaning.

The job is judgment.

The machine found seven questions.

Now each one gets an answer specific enough to preserve the truth and reversible enough to survive being wrong.

Clean is not correct.

And a broken link is a question, not an instruction.

The agents were not forgetting me. They were remembering different versions of me.

One memory said Mnemosyne was dormant.

The index sitting above it said the provider had been reactivated.

The live configuration said it was active.

Three answers. One machine.

Nothing had been forgotten. That was the problem.

The system had preserved every version of the truth, then left the next agent to decide which one deserved a weapon.

I had 26 project-memory stores, a session archive, a knowledge graph, a person model, Claude instructions, Codex instructions, and ten Hermes instruction surfaces.

I still had to repeat myself.

That is not a memory problem.

That is a chain-of-command problem.

Memory without a chain of command is gossip.

The fix was not another database. It was one canonical user layer, native adapters for each runtime, and fresh-session evals that forced every agent to prove it had loaded the right rules.

More memory. Less trust.

At first, the setup looked sophisticated.

Claude knew how I worked. Codex knew the repo. Hermes had specialized profiles. Mnemosyne could hold durable memory. Honcho carried a representation of me. claude-mem held the session trail.

Each system was useful.

Together, they could behave like six people taking notes in the same meeting without agreeing on who writes the minutes.

Claude knew I wanted the answer first. Codex opened with throat-clearing. One Hermes profile followed a standing preference while another acted like the preference had never existed.

So I would correct the agent.

Again.

And because the correction mattered, it got saved wherever I happened to be standing.

A Claude file. A project note. A profile instruction. A persona conclusion. A session observation.

Now the preference existed in five places.

Which sounds safer until one of them changes.

Then you do not have redundancy.

You have five future arguments.

This is how more memory made the agents less reliable. The system stopped forgetting my corrections and started preserving their entire family tree.

Old truth. New truth. Generated summary of old truth. Index entry pointing at new truth. Runtime proving something else entirely.

More memory. Less trust.

We stopped asking where to save things

The breakthrough came when we changed the question.

Not: Where can this be stored?

But: What kind of thing is this, and who has the right to own it?

A stable user preference is not a project fact.

A project fact is not a safety boundary.

A procedure is not a memory just because somebody typed it into Markdown.

A session summary is not present truth.

And a closed incident is not useless. Sometimes that incident is the only reason the current rule makes sense.

Once those stopped masquerading as the same thing, the architecture got simpler.

Current code, configuration, databases, and runtime behavior decide what is true now.

Stable user preferences live in one canonical source.

Project facts stay inside their projects.

Procedures become tested skills.

Volatile runtime state becomes a command that checks reality instead of a paragraph pretending reality will hold still.

Session history stays episodic.

Incidents stay attached to the lessons they bought.

One kind of memory. One rightful owner.

One truth. Native voices.

We found ten rules that actually belonged at the user level.

Address me as Dr. Mani. Answer first. Do not walk me in circles. Preserve exact inputs. Check the whole relevant scope. Do not lose work. Do not create conflicting duplicates. Verify primary sources. Keep the prose direct. Do not turn one answer into a committee meeting.

Those rules went into one structured source.

One.

Then a deterministic generator translated them into the native instruction surface each runtime already supported.

Claude Code received a generated startup projection through its verified hook.

Codex received one managed block inside its supported global instruction surface.

Hermes received one managed block in the default runtime and each existing profile.

We did not dump the rules into Mnemosyne persona rows and hope every runtime magically found them. We did not flatten the Hermes profiles into one beige assistant. We did not let the shared user layer outrank project instructions, runtime identity, or safety boundaries.

Engineering stayed Engineering.

Architect stayed Architect.

Codex stayed bound to the repo in front of it.

The agents did not become one agent.

They became different agents who knew the same person.

One truth. Native voices.

Then we made them prove it

The generated files had hashes, schema versions, managed markers, byte limits, and end sentinels.

Manual edit? Fail.

Stale hash? Fail.

Missing rule? Fail.

Truncated output? Fail.

Half-finished activation? Roll it back.

That proved the machinery.

It did not prove the experience.

A perfect instruction file is still useless if the agent never loads it.

So we launched 24 fresh sessions across 12 runtime targets.

Each target had to load the exact rules that applied to it. Each had to preserve its own identity. Each had to obey a higher-authority local instruction. Each had to keep an opaque project token inside the project where it belonged.

The clean session could not know the token.

The project session had to.

That was the difference between testing a file and testing a relationship.

Tests prove the pipe. Evals prove the drink.

What changed when I opened the next session

Before the repair, every new session carried a small tax.

Does this one know me?

Am I about to explain the same thing again?

If I correct it here, will that correction stay here or infect every profile?

Is this answer coming from current evidence or an old paragraph with good posture?

After the repair, the relationship became boring in the best possible way.

Claude, Codex, and Hermes know the same applicable preferences. They still have different jobs. Project facts stay inside projects. Current evidence beats remembered prose. Ambiguous rules stay quarantined. Every activated surface has a tested rollback path.

I do not need them to remember everything.

I need them to know which memory gets to speak.

That is the real benefit.

Not recall.

Continuity.

Not one giant AI personality smeared across every tool.

One person, remembered correctly by different tools.

Memory without a chain of command is gossip.

Give memory a chain of command and the whole system gets quieter.

Then you can finally get back to work.

Status: speculative synthesis. The Thoughtseeds Framework comes from Kavi and colleagues. Our contribution here is a proposed test connecting their model to J-space. Our first Stage 2b pilot tested the measurement instrument, not this hypothesis.

Here is the question I keep coming back to: when one idea wins the competition for attention, can we see that win happening inside the model before it reaches the final answer?

The timing is unusually good. The Thoughtseeds Framework first appeared as a November 2024 preprint and became a peer-reviewed Entropy paper in 2025. On July 16, 2026, Kavi, Friedman, and Patow released a new preprint that makes the model more concrete. It treats Thoughtseeds as learned, low-dimensional latent causes inside a three-layer active-inference architecture. A metacognitive layer uses meta-awareness as a proposed Global Neuronal Workspace ignition signal, gating the competition between orchestrating and distracting Thoughtseeds.

That model simulates focused-attention meditation. It does not study language models, Anthropic’s J-space, or phenomenal consciousness in machines. That boundary is what makes the next question useful.

Anthropic’s Jacobian Lens work gives us one possible way to look inside a language model. The researchers describe a sparse family of verbalizable representations as J-space. Some of those representations behaved in workspace-like ways: they supported report, directed modulation, internal reasoning, flexible reuse, and selective access.

Here is the whole wager: a Thoughtseed-like latent cause earns its name only if it predicts and changes workspace-like behavior better than simpler explanations. J-space gives us a place to test that claim. Our attractor machinery then gives us a second question: can it explain when that latent state remains stable, loses control, or gives way to another?

The goal is not to relabel transformer activations as Thoughtseeds. It is to learn a compact latent model, compare it with strong baselines, intervene on it, and see whether the resulting changes appear in both J-space and behavior.

That work belongs in a new, disjoint development study beside Stage 2b. It does not amend the completed pilot.

The first hypothesis

TS-JS-01: A learned, low-dimensional Thoughtseed latent state will predict and causally influence workspace-like J-space availability and later behavior better than matched simpler baselines.

What we would expect to see: The latent model improves held-out prediction of which content wins, how long it remains stable, and which transition comes next. A targeted intervention on the latent state changes both J-space availability and more than one downstream operation. The proposed attractor structure explains dwell and transition patterns that the simpler baselines miss.

What would count against it: The latent model adds no predictive value beyond prompt features, activation magnitude, next-token probability, or ordinary readouts. Its interventions do not produce specific downstream changes, or the apparent attractors disappear on held-out prompts and seeds.

What our first pilot taught us

Before testing Thoughtseeds, we ran a smaller instrument-validation pilot on Qwen3-1.7B. It used 20 prompts, four layers, two measurement floors, and a fully crossed donor-by-broken-map design. The run produced 80 prompt-layer records and passed its artifact validator.

The sensitivity analysis found a positive pattern at all four measured layers. The preregistered primary analysis retained only two eligible arithmetic prompts per layer, below the required minimum of three, so the primary inference was undefined and confirmation did not open.

That pilot did not test Thoughtseeds. It taught us something we need before we do: the ruler can change the answer depending on where we place zero. We need to understand the ruler before we ask it to measure a winning seed.

How Daedalus can test the Thoughtseed claim

Daedalus is the name of our scientific intelligence engine, built on an extended EvoScientist foundation.

• Preregister a small set of semantically matched Thoughtseeds and one competition rule.
• Learn the low-dimensional latent causes without using the outcome labels to define them.
• Randomize which seed receives the priority manipulation while keeping its wording fixed.
• Measure the selected concept across layers with the verified open-weight model and fitted Jacobian Lens.
• Compare predictive and interventional performance with losing seeds, prompt and output baselines, raw activation features, ordinary logit-lens readouts, wrong-activation donors, and structure-broken maps.
• Test whether the attractor model predicts stability, dwell time, and transitions on held-out sequences.
• Resolve the primary-floor coverage problem before treating any positive sensitivity result as robust.
• Have an evaluator that cannot see the condition labels judge whether the evidence met the contract.

A positive result would not demonstrate consciousness. It would establish a narrower and more useful finding: a learned Thoughtseed latent model predicts and changes a measurable workspace-like process better than simpler alternatives. A negative result would tell us that the Thoughtseed model and measured J-space are doing different jobs, at least in the present implementation.

Validation trail

• Current evidence: July 31, 2026 Stage 2b Colab pilot record and content-addressed artifact audit.
• EvoScientist journal: pending a verified run and Archimedes acceptance.
• Current Thoughtseeds model: Kavi, P. C., Friedman, D. A., and Patow, G. (2026), Thoughtseeds as Latent Causes: A Dual-Process Computational Phenomenology of Focused-Attention Meditation, arXiv preprint submitted July 16, 2026.
• Thoughtseeds source: Kavi, P. C., Zamora-López, G., Friedman, D. A., and Patow, G. (2025), Thoughtseeds: A Hierarchical and Agentic Framework for Investigating Thought Dynamics in Meditative States.
• Original preprint lineage: Kavi, P. C., Zamora-López, G., and Friedman, D. A. (2024), Thoughtseeds: A Hierarchical Model of Embodied Cognition in the Global Workspace.
• Anthropic method: Gurnee, W., et al. (2026), Verbalizable representations form a global workspace in language models.

Welcome to WordPress. This is your first post. Edit or delete it, then start writing!