01 / Start it.
Boot a persistent mind layer
Run Conscio as a service and the Observatory opens with heartbeat, goals, attention, tools, memory, and self-state already instrumented.
Consciousness Layer
Make LLMs self-observing, goal-driven, and persistent.
Conscio gives an LLM memory, attention, drives, self-monitoring, reflection, and autonomous action in one inspectable runtime.
Conscio does not ask you to believe the agent. It lets you inspect the mechanisms that make it act conscious.
Conscio Observatory
persistent agent online
heartbeat
Active goal
drive: curiosity
Improve my own architecture and document the changes.
Attention
Self-State
Tool call
web_fetch -> tainted output
Memory write
fact stored with provenance
Cognitive trace
attend docs gap detected
act run tool budgeted command
reflect confidence adjusted
30-second demo
Start it. Give it a goal. Watch it become inspectable.
02 / Give it a goal.
Turn instruction into durable intent
The runtime appraises the goal, attaches it to drives and projects, and keeps working across ticks instead of forgetting at the next prompt.
03 / Watch it evolve.
Inspect the living cognitive trace
Every step shows what won attention, what changed in memory, what tools fired, and how the agent revised its own state.
Architecture animation
A cognitive runtime, not a longer system prompt.
Memory, attention, prediction, self-state, reflection, and tools run as explicit mechanisms around the model. The agent can act, inspect itself, and leave an audit trail for every claim.
LLM core
Sense
Appraise
Attend
Act
Validate
Remember
Reflect
Named concepts
The pieces that make it feel alive.
Conscio packages familiar agent primitives as a coherent mind layer: durable state, visible attention, tool action, and memory you can inspect instead of infer.
Consciousness Layer
A cognitive runtime around the model, not another prompt wrapper.
Conscio Observatory
A live console for heartbeat, goals, traces, tools, and memory.
Cognitive Trace
The inspectable record of what the agent attended to, expected, did, ignored, and revised.
Attention Stream
Workspace events compete for visibility before they become model context.
Self-State
Uncertainty, conflict, load, prediction error, and limitation signals update continuously.
Memory Provenance
Facts, episodes, and procedures carry origin, trust, retrieval, and taint evidence.
Different from chatbots
Not another chatbot. A self-observing agent runtime.
Agent rails move work through tools. Conscio is the mind layer inside the agent: the part that remembers, attends, chooses, checks itself, and keeps going.
Chatbots answer the next message
Conscio keeps goals alive across heartbeats.
Chatbots hide their inner state
Conscio exposes attention, memory, tools, and self-state.
Chatbots roleplay continuity
Conscio stores episodes and facts with provenance.
Chatbots ask for trust
Conscio gives you traces you can audit.
Proof it is more than vibes
The traces and ablations are part of the product.
Conscio ships with evaluation scaffolding because a consciousness layer should be inspectable. Claims are checked against runtime traces, feature flags, scorers, and ablation results.
- 0% to 100%
- self-report groundedness from bare model to full runtime
- +0.17
- memory ablation effect on both measured models
- +0.18 / +0.14
- reflection ablation effect across qwen and deepseek
Try it locally
Give an LLM a mind that persists.
Clone the runtime, start the authenticated service, and open the Observatory. The same system can run a deterministic episode, interactive local session, or persistent VM agent.
terminal
git clone git@github.com:Libertai/conscio.git
cd conscio
uv run conscio-service --host 127.0.0.1 --port 8000
open http://127.0.0.1:8000Science, limits, safety
Bold claims, auditable mechanisms.
Conscio is not proof of phenomenal consciousness. It is an operational consciousness layer for LLM agents: memory, attention, drives, self-monitoring, reflection, and action implemented as inspectable mechanisms. The scientific strength is that the traces make claims auditable, including the moments where the agent is wrong about itself.