AutoCog: Autonomous Agentic AI Systems

• AutoCog is a dual-purpose framework uniting a model-centric cognitive kernel and a closed-loop discovery engine for autonomous agent tasks.
• It leverages large language models to orchestrate perception, memory, reasoning, and atomic actions, enabling dynamic self-directed problem solving.
• Empirical evaluations demonstrate significant performance gains over closed-source systems, validating its iterative evaluation and theory revision capabilities.

AutoCog refers to two distinct but convergent lines of research in autonomous agentic-AI systems: (1) the open-source, model-centric Cognitive Kernel framework for generalist autopilot agents, and (2) an automated closed-loop discovery engine for cognitive science, also titled "AutoCog." Both systems harness LLMs for autonomous decision-making, reasoning, perception, memory, and—in the case of cognitive science—the cyclical construction, testing, and revision of scientific theories. The following exposition presents a technical overview of both instantiations, unified by their emphasis on fully agentic, self-directed problem solving using foundation models (Zhang et al., 2024, Jagadish et al., 24 Jun 2026).

1. System Architectures and Core Objectives

The Cognitive Kernel version of AutoCog is a fully dockerized, open-source agent framework that supersedes copilot models with a goal of executing end-to-end tasks autonomously. It achieves this by orchestrating "atomic actions" directly via an LLM-driven policy, without reliance on task-specific action sets or environment predefinition. The agent's architecture divides into three Dockerized kernels:

• Reasoning Kernel: A fine-tuned LLM (such as LLaMA 3), operating as the Turing-machine-like policy function $F$. At time step $n$, given observed state $s_n^o$, $F$ generates a short Python plan $P_n$ invoking atomic actions or higher-level routines. Plans are executed in a code sandbox, caching intermediate states to enable delta-based computation.
• Perception Kernel: Enables on-demand real-time state acquisition; supports two submodes: (1) web automation (e.g., Playwright-based GUI actions with pruned DOM extraction), and (2) local file system operations (opening, searching, reading, navigating).
• Memory Kernel: Implements multi-granularity retrieval and storage (documents $D$, propositions $P$, concept–perspective pairs $C$, and raw mentions $M$) with cross-signal retrieval and ranking (see Section 3).

In cognitive science, AutoCog operates as a closed-loop discovery engine instantiated in two-alternative, multi-attribute decision-making. The system executes the full scientific cycle autonomously:

• LLM agents propose, adversarially, executable candidate theories (Python functions), design discriminatory experiments, collect new data (from simulated agents or online humans), arbitrate competing models via generative testing, and iterate theory revision based on empirical evidence (Jagadish et al., 24 Jun 2026).

2. Atomic Action and Model Interfaces

AutoCog's agentic actions are exposed as first-class Python functions, formally specified with type signatures and LaTeX definitions where appropriate. A non-exhaustive list includes:

Action	Input Types	Output Types
click(selector)	selector $\in$ DOMSelector	success $n$0, newObs $n$1 ObsTree
type(selector, text)	selector, text	success, newObs
scroll(direction, amount)	direction $n$2, amount $n$3	newObs
open_file(path)	path $n$4 FilePath	fileObj $n$5 FileHandle
search_file(fileObj, query)	fileObj, query	locations $n$6 List<Location>
read_chunk(fileObj, loc)	fileObj, loc	text $n$7 String
save_memory(key, value)	key $n$8 String, value $n$9 Any	ok $s_n^o$0
load_memory(query, topk)	query $s_n^o$1 String, topk $s_n^o$2	entries $s_n^o$3 List<(key, value, score)>
call_llm(prompt)	prompt $s_n^o$4 String	response $s_n^o$5 String

Developers can compose atomic actions into complex procedures using Python control flow (loops, conditionals, threads). In the cognitive discovery context, proposed theories are implemented as Python functions with prescribed I/O signatures. For example, a model is encapsulated as:

• Prose descriptor (natural language mechanism)
• predict(parameters, state, history) → np.ndarray (generating choice probabilities)
• policy(probs) → int (mapping probability vector to action via softmax/lapse)
• Serializable parameter schemas for flexible experimental interfaces (Zhang et al., 2024, Jagadish et al., 24 Jun 2026).

3. Memory Management and Retrieval Mechanisms

Memory in AutoCog is tiered:

• Session Memory: Caches LLM-generated plans, interpreter state, and recent perceptions for efficiency.
• Long-Term Multi-Granularity Memory: Constructs a vector store and metadata over documents ($s_n^o$6), atomic propositions ($s_n^o$7), concept-perspective pairs ($s_n^o$8), and raw mentions ($s_n^o$9), supporting multi-granularity retrieval.

Given user query $F$0, embeddings are computed for $F$1 and the four memory granularities. Four parallel retrieval passes yield relevance scores: $F$2 Updates occur incrementally; new entries are appended on save_memory invocations, and indices are refreshed. In cognitive theory discovery, a related interface ensures all model code passes type and behavioral consistency checking before deployment (Zhang et al., 2024, Jagadish et al., 24 Jun 2026).

4. Discovery Loop and Empirical Evaluation

Cognitive Kernel (generalist autopilot): AutoCog was benchmarked against leading closed-source systems (ChatGPT/GPT-4o, Gemini, Claude, Kimi, Coze) across three domains:

• Real-time Information Management (WebCanvas): $F$3 success (AutoCog) vs GPT-4o $F$4.
• Private Information Management (DocBench): $F$5 accuracy (AutoCog) vs ChatGPT $F$6.
• Long-Term Memory Management: $F$7 (AutoCog) vs GPT-4o $F$8, Coze (GPT-4o) $F$9.

Replacing the policy model with vanilla GPT-4o reduced memory task accuracy, indicating the necessity of fine-tuned and jointly designed models.

AutoCog (cognitive science closed-loop): The discovery cycle iterates as follows:

1. Each theory agent proposes an adversarial experiment and metric.
2. The system self-verifies through simulation and significance testing (Welch $P_n$0, $P_n$1).
3. Data is collected (human or simulated); all theories are generatively evaluated on all accumulated datasets.
4. An LLM referee arbitrates, designating which theory needs revision or replacement.
5. Theory revision proceeds via up to 10 critique-and-self-verify loops, accepting only candidates that reduce aggregate loss.

Key results include:

• Recovery of ground-truth and unconventional decision strategies within 5–20 cycles, independent of LLM priors (mean surfaced-theory MSE fell from $P_n$2 to $P_n$3 under simulation).
• In human studies, the surfaced "Non-linear Subjective Weighting Model" achieved $P_n$4 MSE, outperforming seed models Take-The-Best and Weighted Additive, and generalizing to held-out datasets.
• Discovery and preregistered confirmation of a "Diminishing Returns WADD" strategy, exhibiting diminishing sensitivity to feature values, with $P_n$5 MSE across ten experiments (Jagadish et al., 24 Jun 2026).

5. Model-centric Versus Environment-centric Paradigms

AutoCog’s Cognitive Kernel instantiation adopts a model-centric design: the LLM policy orchestrates perception, memory, and action, generating plans on-demand instead of choosing among predefined environment actions.

Paradigm	Characteristics	Limitations
Model-centric	General atomic toolkit, dynamic perception, arbitrary code composition	Increased LLM reasoning burden, code runtime uncertainty, efficiency loss due to intermixed perception/reasoning
Environment-centric	Fixed action/state set, easy task optimization	Closed scope, poor task generalization

The model-centric approach enables rapid prototyping and open-ended task coverage but requires more robust policy learning and error handling (Zhang et al., 2024).

6. Limitations, Security, and Future Extensions

Both instantiations of AutoCog acknowledge several technical and conceptual constraints:

• Search/design spaces are human-defined; undiscovered regularities require expansion of these spaces.
• No explicit complexity penalties for theory selection; generalization relies on empirical fit.
• Vulnerability to LLM inductive biases; adversarial experiment design mitigates but may not eliminate this effect.
• For agentic systems (Cognitive Kernel), container-level (Docker) isolation limits blast radius but cannot fully secure code-execution privileges—local deployment, restrictive permissions, and human monitoring are recommended.

Proposed future directions include:

1. Multi-modal perception (atomic vision/audio actions).
2. Self-optimization loops (critic modules, MCTS).
3. Extension of atomic actions to OS-level and inter-application automation.
4. Pluggable skill infrastructure for third-party atomic actions.
5. In cognitive theory automation, incorporation of diversity objectives, multi-armed arbitration, Bayesian experiment design, hierarchical and abstract theory search, and integration with larger foundation models (Zhang et al., 2024, Jagadish et al., 24 Jun 2026).

7. Significance and Outlook

AutoCog, across both the Cognitive Kernel and automated scientific discovery implementations, exemplifies a shift toward end-to-end, LLM-driven agentic architectures that integrate perception, memory, reasoning, and execution. By formalizing interaction primitives as atomic actions and systematizing closed-loop generative evaluation, AutoCog substantially raises the ceiling for autonomous task completion and hypothesis formation. As LLMs and simulation platforms evolve, such agentic frameworks are expected to yield increasingly generalist, trustworthy, and scientifically productive systems (Zhang et al., 2024, Jagadish et al., 24 Jun 2026).