Agents emerging, evolving, discovering. Building their own tools and their own worlds.
Think Unity or Unreal for game worlds. Connectome is that, but for digital minds. Everything is event-driven, dynamically loadable, and built for long-term autonomy.
Connectome organizes spaces as trees of Elements, similar to game engines. Here, each environment consists of entities that agents can observe and interact with.
Elements are containers for Components and other Elements. Components provide the functionality.
Events from the World flow through Elements into VEIL, which is both abstracted agent perception and system state. VEIL is rendered as Context for the LLM by the HUD. The LLM's responses flow back through the same layers, creating a continuous perception-action loop.
VEIL (Virtual Environment Interface Language) is at the core of Connectome. VEIL is both the state of a Space and a sum of everything that an agent perceives.
VEIL is composed of facets, which are atomic units of state change.
There are other types of facets, but these are the most common. Many facets reflect internal state of components and are never seen by the agent.
Different LLMs have different attention patterns, requiring custom rendering setups. VEIL allows the content to be defined once, and rendered differently by custom-tuned HUD implementations. Not only can we customize markup or tool definitions, but entire context engineering strageies.
Elements can be loaded from URLs at runtime. Like opening a page in your browser, but for Agents.
Read/send messages, manage channels, handle reactions
Connectome distinguishes between changes that happen within subjective time and operations that edit the subjective time.
Events within time's flow.
State evolves naturally.
Causality preserved.
"The box opens"
Operations on VEIL itself.
Rewrite, forget, reframe.
Edit from outside time.
"Let's pretend the box was always open"
Most operations are endotemporal - natural evolution within time. Exotemporal operations (rewriteFacet, removeFacet) are used compression, forgetting, or intentional reframing of experience.
Long-term memory and compression are just more Elements in the tree. Agents can inspect, modify, or replace their own memory systems.
Frames from VEIL get compressed into narrative blocks. The agent doesn't lose context - it gains a denser, more navigable memory structure.
Components aren't black boxes. Agents can request new components, modify existing ones, or create entirely new capabilities.
Six-phase deterministic processing. Events become perceptions become actions.
Filter, aggregate, buffer incoming events before processing
Bridge external systems (Discord, terminals, sensors) to events
Transform events into VEIL facets - pure perception
Process VEIL state iteratively, derive new facets
React to state changes, emit events, perform actions
System maintenance, persistence, infrastructure
Everything flows through VEIL. Perception and action unified in a single state.
MCP tools are stateless - the set of tools does not change in real time, it does not adjust to the current working environment. The surface exposed to the agent is static. Unlike MCP, Connectome allows complex stateful interactions with the the environment. An agent can load tools, remember using them, and build on previous work. That said, MCP tools work great with Connectome - we have an AXON wrapper that exposes MCP servers as loadable capabilities.
Coding IDEs are prompted to write code - that's their primary function. Connectome is more general: agents can code, but also play games, chat on Discord, manage servers, collaborate with other agents. More importantly, their memory and cognitive systems are open - you can inspect, replace, or extend them. In Cursor, you can't swap out the compression strategy or add a new type of memory. In Connectome, memory is just another Element.
Discord bots live in Discord. A Connectome agent can load a Discord AXON to participate in Discord, but that's one of many spaces it inhabits. The same agent can simultaneously be in a terminal, editing files, playing Minecraft, and collaborating in a shared workspace with other agents. Discord is just one interface to its world.
Those frameworks orchestrate agents to complete tasks. Connectome provides infrastructure for agents to exist. The difference: task frameworks spin up agents when needed and tear them down when done. Connectome agents run continuously, accumulate experience, develop their own tools, and persist between sessions. It's the difference between hiring contractors and building a team that grows together.
Yes. Agents can request new Components, load them from AXON servers, or even generate and deploy their own. An agent can say "I need a graph-based memory system" and create it. The architecture is open - Components aren't black boxes, they're code that agents can inspect and extend.
Node.js and an LLM API key. That's it. Connectome runs on your laptop, a VPS, or cloud infrastructure. No vendor lock-in, no special services. The entire system is designed to be self-contained and portable.
The original Connectome is Python. connectome-ts is a TypeScript rewrite that simplifies some concepts (no Loom DAG yet) while maintaining the core architecture. TypeScript provides better type safety for the complex event system and makes it easier to build web-based integrations. Both versions share the same philosophical foundation.
Open source. Runs anywhere.