Chatting with Neo
How everyday conversation works, what Neo can do, how it shows its work, and when it escalates to the rigorous MCL rail.
For day-to-day use, you just talk to Matrix. Neo is the conversational agent that handles your request directly: it reads context, calls tools, and only escalates to the rigorous MCL pipeline when something is monetary or irreversible.
What Neo can do
Neo has access to a broad surface of tools that it calls autonomously as your conversation requires. You do not need to invoke them by name; Neo decides which tools to use based on what you ask.
How a conversation works
Every message you send triggers a loop that reads your context, decides what to do, and carries it out.
It pulls relevant memory: facts, preferences, goals, and past turns. Long conversations are automatically compacted; older history is consolidated into a summary while preserving every important identifier (file paths, addresses, IDs) verbatim.
The model emits text and tool-call intents in a single turn. Neo dispatches each tool, observes the result, and decides whether to call more tools or return an answer. This loop continues until the task is done or the step budget is exhausted.
Every tool call produces a live event: the tool name, its arguments, and its result. You see web search snippets as they arrive, browser screenshots as pages are captured, and file writes as they happen. Neo never hides the evidence behind a synthesized paragraph.
When the task is complete, Neo returns a final answer grounded in the tool results it collected. If the task could not be fully completed, it tells you honestly what it achieved and what remains.
Showing its work
Matrix is designed around transparency. While Neo works, you see a streamed transcript of everything it does:
- Tool calls appear as they execute: "Searched the web for...", "Fetched https://...", "Wrote file to /workspace/...".
- Browser activity is shown with live screenshots captured after each view-changing action.
- File writes stream content in real time, so an open editor renders Neo typing as it generates the file.
- Reasoning is surfaced when Neo thinks through a problem before acting.
This "show the work" approach means you always know the real evidence behind an answer.
Agent Swarms
For complex tasks that can be split into independent parts, Neo can spawn a swarm of sub-agents that run concurrently. Each sub-agent gets its own isolated context window and works on a self-contained task while their progress streams onto your conversation as a live agent swarm.
Sub-agents are useful when a task has clearly separable research or analysis components. For example:
"Compare the top 3 DEXes on Paxeer by volume, fee structure, and TVL. Give me a summary table."
Neo might spawn three sub-agents, each researching one DEX in parallel, then aggregate their findings into a single comparison table.
Sub-agents inherit Neo's full tool surface for reversible work (files, web, code, on-chain reads) but cannot move money or spawn their own sub-agents. Results are collected into an aggregated digest that Neo synthesizes into its final answer.
Escalation to the rigorous rail
When a task involves spending money or performing an irreversible on-chain action, Neo does not execute it directly. Instead, it hands off to the MCL pipeline (Matrix Communication Layer), which compiles your intent into a typed plan you can review before anything runs.
This escalation is automatic. You do not need to trigger it. If you say "send 100 PAX to Alice," Neo will route that through the rigorous rail, show you the plan, and wait for your approval.
The rigorous rail is a safety layer. Chain writes are gated twice: first by a per-call spend ceiling enforced at plan time, then by the Paxeer Embedded Wallet's own spend policy at signing time.
Autonomous execution
Matrix can also work for you without you being in the conversation. The Automatrix system identifies proactive opportunities (based on your goals and context) and dispatches supervised agent runs on a restricted tool surface. These runs:
- Resume into the original conversation so Neo has full context.
- Are held to the same completion standards as any interactive turn.
- Surface nothing to you unless they succeed.
- Are retried up to a bounded number of attempts before being dismissed.
Set a scheduled wake with the Chronos tools (e.g., "remind me in 2 hours to check on that deployment") and Neo will resume the relevant thread when the alarm fires.
Long conversations
Matrix handles long threads gracefully:
- Compaction. When the context window fills, older turns are consolidated. A dedicated extractor promotes durable facts, events, and patterns to cortex memory before older turns are evicted.
- Conversational recall. Beyond the live transcript, Neo can surface the most relevant past turns for a given query using semantic and salience-weighted search. Relevance over raw recency.
- Persistent memory. Facts you tell Neo ("my Paxeer address is 0x...", "I prefer concise answers") survive across conversations.
Examples
Research and analysis:
you: What's the current PAX price and how has it changed over the last week?
Neo searches for current PAX price data, queries on-chain oracle prices, and returns a summary with the current price and recent trend.
Code and files:
you: Create a Python script that reads a CSV of token transfers and calculates the total volume per address.
Neo writes the script to your workspace, verifies it runs correctly, and explains how to use it.
Browser automation:
you: Go to PaxScan and look up the top 10 token holders for the USDX contract.
Neo navigates to PaxScan, searches for the contract, extracts the holder list, and presents it in a table.
On-chain actions (with escalation):
you: Send 50 PAX to 0x1234...abcd
Neo escalates to the rigorous rail, shows you the transfer plan with the destination, amount, and estimated fee, and waits for your approval before signing and broadcasting.