Features Candidate List

[igordayen]

OVERVIEW

As relatively beginner is the area of cognitive aspects of human-machine interaction (still learning college books:) ) i employed as of now AI authoirity in order to answer questions:

1. what aspects of ACT are missing in GUM
2. what aspects of general cognitive architecture are missing in ACT
3. what aspects of ToM would be valuable add-ons.

Please see recommendation:

https://chatgpt.com/s/t_69c1b83290d4819182020957efca3851

Top 5 feature candidates:

1. Implicit Learning Layer

→ intuition, habits, latent preferences

2. Action Layer (from propositions)

→ converts understanding into execution

3. Goal Context

→ disambiguates meaning and guides behavior

A goal doesn’t contain actions—it selects and evaluates them.

4. Attention Mechanism (primary + derived hybrid)

→ selects what matters now

5. Theory-of-Mind Lite

→ models user knowledge and expectations

One-line synthesis

GUM understands → Goal contextualizes → Attention selects → Action executes → Procedural layer learns

Note:

Implicit memory is about patterns and intuition; procedural memory is about skills and actions built on top of those patterns.

[jimador]

Thanks @igordayen for putting this list together.

Reading through it, the items split pretty cleanly for me into two buckets:

• capabilities that already exist but need to be surfaced and composed within DICE's proposition framework
• capabilities that likely sit outside the core intent of DICE or require meaningfully different systems

On (2) Action Layer and (3) Goal Context, Embabel already provides the primitives. @Action, Goal, @Achieves, and the GOAP-style planner are all there. What DICE contributes is the substrate: extracted propositions become the world state that goals evaluate against, and actions fire when the accumulated state crosses some completeness threshold.

Most of the plumbing exists. The interesting piece is the completeness gate - recognizing when a partially constructed domain model, built incrementally through conversation, is sufficient to materialize and act on. That's the pattern I'd want DICE to make straightforward: conversation as elicitation, the agent incrementally builds the model, and then surfaces "should I do X now?" once the required inputs are satisfied. It's a collaborative progression through a process, not form-filling and not fully autonomous execution.

(1) Implicit Learning and (5) Theory-of-Mind Lite feel like they fall outside the core intent of DICE, though I'm open to a different read. Implicit learning (in the cognitive science sense) typically implies gradient-based adaptation to capture latent patterns and habits. ToM Lite implies a user-modeling layer that tracks what the user knows versus what the agent believes they know. Those are valid capabilities, but they're different in kind from DICE's proposition-centric model. They read more like adjacent systems that consume DICE's proposition stream rather than features that live within DICE itself.

(4) Attention is where most of the leverage is, and where the problem becomes non-trivial. "Select what matters now" is the simple framing. In practice, for long-horizon agents, the challenge is selecting what matters despite drift. Conversations branch, clarify, and wander, and goal-relevant context gets displaced by recency. A purely recency- or salience-driven model can fail quickly (especially on weaker models). I've got some experience here, so I can give a quick brain dump:

---

What's worked well for me on top of DICE is treating attention as layered, driven by an authority hierarchy instead of a flat hot vs cold split:

• Invariants - Pinned facts that survive everything: domain rules, constraints, identity. Canon-tier. Only change through explicit gating.

• Goal-adjacent context - First- and second-order adjacency to the active goal. Computed, not pinned, but elevated above working memory.

• Working memory - Activation-ranked recent context with natural decay.

• Cold storage - Persisted and retrievable, but not in attention by default.

The authority layer is what makes this hold together. Without it, importance drifts with the conversation. With it, you can explicitly separate invariant facts, goal-adjacent context, and transient memory. The effective attention set becomes:

invariants ∪ goal-adjacent ∪ top-k(working memory)

That structure makes drift survivable. The conversation can wander, but constraints and goal-relevant context stay stable.

There are other ways to approach this, but explicit authority is where this landed. Most existing systems focus on retrieval or storage. MemGPT pages context, Mem0 and A-MEM improve extraction and persistence, Graphiti handles temporal updates. The harder problem is deciding which facts continue to carry weight turn after turn, regardless of what was retrieved most recently. IMO, DICE's proposition model is a stronger starting point for that. An authority-driven attention layer makes the working set deliberate instead of opportunistic. Facts stay in scope until something explicitly displaces them, which fits conversation-driven workflows better than retrieval alone.

It's also worth separating attention from prompt. Attention is what the system believes should be salient. The prompt is what actually gets sent. They diverge. Facts can be in attention but excluded due to budget, or in the prompt but ignored by the model. Treating attention as a first-class construct, separate from prompt assembly, makes both easier to reason about.

There are real engineering challenges here:

• Authority has to stay generic - Different domains define authority differently. The framework needs a pluggable model with a sensible default.

• Inference cost adds up fast - Extraction, conflict detection, relevance scoring, semantic comparison all require LLM calls. That gets expensive, especially for smaller deployments. You can mitigate with caching, batching, embeddings, and background work, but there's no free option.

There are other concerns too like prompt caching, developer ergonomics, and auditability, but those are secondary to the core point. There are a lot of 2nd and 3rd order concerns to investigate.

One broader observation: the value of explicit attention scaffolding goes up as model size goes down. Frontier models can tolerate drift. Smaller models cannot. Many real deployments are constrained by cost, privacy, or infrastructure and end up on smaller models. Those systems need stronger memory scaffolding to stay on task. An attention layer integrated with DICE could fill that gap.

Another: basic attention rules are all useful even in short-horizon agentic work, especially when they're defined by the business rather than encoded by developers. The interesting move is letting these live as data inside DICE (or inferred from business domain context) and getting picked up by the framework automatically, instead of being baked in as hard constraints in code or config.

... That was a lot - happy to go deeper on attention layering or the completeness gate if useful.

[igordayen]

@jimador - thanks for feedback and happy to collaborate with you and Rod on attention-focus behabioral pattern modeling.
@johnsonr - could you please review features list / advase on direction.
Thanks