Building the Foundation for a Non-Linguistic AI Mind: Two Weeks In
Building the Foundation for a Non-Linguistic AI Mind: Two Weeks In
This is the fourth post in a series on non-linguistic cognitive architectures. The first post examined AI history through the lens of search strategies. The second post introduced Project LOGOS and its graph-based approach to machine cognition. This post reports on two weeks of focused development.
Two weeks ago, Project LOGOS didn't exist. Today it's a working cognitive architecture that represents mental states as causal graphs rather than linguistic tokens. This post documents how we built it and what we've learned.
The System
Project LOGOS consists of five main components.
- Logos core, the foundational library providing the Hierarchical Causal Graph, Compact World Model, and SHACL-based ontology validation. Every other component depends on this.
- Sophia, the cognitive core, responsible for reasoning, planning, and memory management. Sophia owns the Hierarchical Causal Graph and decides what experiences are worth promoting to long-term memory.
- Apollo, the interface layer, providing command-line and web interfaces for interacting with the agent. Apollo visualizes the agent's state and serves as the vehicle for user interaction.
- Hermes, the language services layer, handling speech-to-text, text-to-speech, embeddings, query generation (Cypher for Neo4j), and LLM integration. Hermes also performs initial salience filtering, identifying what's surprising or interesting in incoming data.
- Talos, the execution layer, translating cognitive decisions into external effects and providing hardware abstraction for sensors and actuators.
These aren't just modules in a monorepo. Each is a separate repository with its own test suite, Docker configuration, and API specification. They share a common base image and install from source at build time. The architecture is designed for independent deployment and horizontal scaling.
Where We Started
Two weeks ago, Project LOGOS was an idea and a question. The idea came from following researchers like Yann LeCun who argue that large language models are a dead-end for general intelligence; next-token prediction, however scaled, won't get us to systems that truly understand the world. The question followed naturally: how do we actually think, learn, and reason? Language plays a role, certainly, but we weren't learning through language when we learned the basic ground rules of the universe as infants. Understanding seems to require grounding in physical experience; without it, even sophisticated text processing is just symbol manipulation without meaning.
That was it. No specs, no architecture documents, no code. Just that inspiration and a willingness to start building. The design emerged through the process of implementation by brainstorming and coding in parallel, letting each inform the other.
Phase 1: Complete
Phase 1 focused on formalizing the core abstractions, namely the Hierarchical Causal Graph, the ontology, and the foundational infrastructure. This is now done. The HCG implementation is stable. The SHACL-based ontology validation works. The basic Compact World Model operations are functional. The development cluster (Neo4j, Milvus) is running.
Phase 2: Complete
Phase 2 focused on making the system operational. All milestones achieved:
P2-M1: Service Containerization - Complete. All five components now have production-ready Docker configurations with proper health checks, volume management, and environment variable handling.
P2-M2: CI/CD Pipeline - Complete. GitHub Actions workflows for automated testing, coverage reporting, and quality gates across all repositories.
P2-M3: Apollo Dual Surface - Complete. Both CLI and browser interfaces operational. Real-time WebSocket updates, media upload UI, full SDK integration.
P2-M4: Perception & Observability - Complete. Media ingestion pipeline working. OpenTelemetry dev stack operational. Verification evidence captured in apollo/docs/evidence/.
Update: Phase 2 verified complete December 2, 2025. See PHASE2_VERIFY.md for full checklist.
The Infrastructure Detour
Much of the past two weeks went into work that produces no visible features but makes everything else possible.
Containerization
Every component now has a functioning Docker setup with consistent patterns. Those patterns cover:
- Health check endpoints that actually verify service readiness
- Compose files for development, testing, and production
- Port schemes that avoid conflicts when running multiple services
- Volume configurations for data persistence
This sounds straightforward. It wasn't. Each component had different assumptions about configuration, different dependencies, different startup sequences. Components reference shared ontology files and cross-repository resources, requiring explicit path configuration. Harmonizing these while preserving each component's autonomy required careful work.
Test Stack Standardization
We converged on a consistent test architecture using pytest with structured markers, coverage requirements (80% target), and separation between unit, integration, and system tests. This required updating test fixtures, reorganizing test directories, and establishing clear patterns for handling external dependencies.
Integration Test Rehabilitation
The existing integration tests were written before the architecture was stable. They made incorrect assumptions about which components talked to which services. Some tested code paths that no longer existed. Others mocked dependencies in ways that hid real integration issues.
We didn't just fix the tests; we established a tiered approach with clear scopes:
- Tier 1 covers core library integration (HCG operations, ontology validation)
- Tier 2 covers service integration (Sophia with Neo4j, memory persistence)
- Tier 3 covers cross-service integration (when Hermes is available)
Each tier has explicit markers and can be run independently based on available infrastructure.
Engineering Observations
SHACL Works
The ontology validation layer catches structural errors before they propagate. When a causal link references a nonexistent node type, the system fails fast with a clear error. When a belief graph violates cardinality constraints, validation catches it. This investment in schema enforcement is paying dividends as the system grows.
Standardization Compounds
Early decisions to standardize Docker patterns, test structures, and configuration approaches are accelerating current work. When we add a new feature, we're not simultaneously inventing how to test it, deploy it, and configure it. The patterns exist; we follow them.
Documentation Lags
Architecture documents and code comments describe the system as designed, not always as built. Some drift is inevitable, but we're actively reconciling documentation with implementation, particularly for integration points that evolved during containerization.
Current State
Operational
- Neo4j graph database with ontology-aware queries
- Sophia memory and diary processing
- Belief graph management
- Real-time graph visualization in webapp
- Docker-based development environment
- CI pipelines with coverage enforcement
Outstanding
- Perception pipeline (needs infrastructure work for media processing)
- Talos action execution (interfaces defined, implementation incomplete)
- Cross-service integration tests (blocked on Hermes stability)
- Production deployment configurations
- Performance optimization (currently optimizing for correctness)
What's Next
Immediate priorities:
- Complete P2-M3 prototype wiring with a full perception-to-action demo
- Expand P2-M4 integration test coverage
- Stabilize Hermes for production use
- Begin P2-M5, the performance baseline establishment
Longer term, Phase 3 will focus on the reasoning layer, the actual cognitive operations that manipulate the HCG during deliberation. The infrastructure work of Phase 2 exists to support that goal.
Summary
Two weeks of focused development took an idea and turned it into a testable, deployable system. The visible results, a working webapp and green CI pipelines, represent the tip of an iceberg of infrastructure work.
Building non-linguistic cognitive architectures is hard. Building them in a way that supports ongoing development and eventual collaboration is harder. The time invested in containers, tests, and configuration isn't glamorous, but it's the foundation that makes everything else possible.
The goal remains unchanged, building an AI system that reasons causally about the world rather than predicting tokens. We're closer than we were two weeks ago.
Project LOGOS is an open research project exploring graph-based cognitive architectures. The code is available on GitHub.