Engineering Architecture: Unified Memory, Agent Relay & Agent Telemetry

We recently reached key engineering milestones across multi-agent supervisory coordination, persistent memory, and unified agent telemetry.

Below is an engineering overview of our technical architecture and how these systems empower developers running multiple autonomous agents.

Unified cross-agent persistent memory

One of our core features is a shared memory layer that transcends individual models, using unified memory graphs connecting all your cloud and local agents.

Memories, tool schemas, and project context are now automatically synced. When Grok discovers an architectural constraint during deep analysis, your local local CLI runtimes bot and Manus web agents immediately have access to the same context.

This eliminates repetitive prompt-pasting and ensures all your agents operate on identical ground truth.

Agent Relay v2: Bidirectional handoffs

We completely overhauled our task transfer protocol to support complex bidirectional workflows between cloud and local agents.

Agent Relay now supports real-time execution streaming, artifact validation, and automatic retries. If an agent encounters a tool error or token boundary, it smoothly delegates to a partner agent without halting the pipeline.

This enables resilient, multi-step agent chains that can run autonomously for hours.

Supervisory Planning with Claude & MCP

Decomposing complex, multi-agent objectives requires deep architectural reasoning.

Artificial uses Claude as the lead reasoning supervisor to parse high-level objectives into dependency-managed task graphs. Claude coordinates tool invocations, dynamically arbitrates task state, and dispatches specialized execution steps across Model Context Protocol (MCP) servers and connected runtimes.

This provides structured, deterministic orchestration without hallucinations or state drift.

Local engine connectors: local CLI runtimes & Hermes

Alongside cloud upgrades, we shipped native zero-config connectors for local models including local CLI runtimes and Hermes.

Local models now appear directly in your agent sidebar, allowing you to run private background daemons that trigger cloud agents on demand.

Deep Dive: The Unified Memory Graph and Semantic Caching

Traditional chat applications treat conversation history as an append-only flat list of text messages. For a multi-agent system, this naive approach collapses immediately under context limits and quadratic token pricing.

Artificial Computer implements a multi-tiered Unified Memory Graph:

• Working Context (L1 - Ephemeral): High-speed, in-memory scratchpads specific to the active agent execution frame. Contains immediate step reasoning, tool call parameters, and raw JSON returns.

• Session Memory Graph (L2 - Relational & Semantic): A structured directed graph tracking entities, files, functions, and cross-agent decisions within the current workspace session. If an agent identifies that a database table schema has changed, that fact is committed to the session graph.

• Durable Knowledge Store (L3 - Vector & Hybrid Search): Persistent embeddings computed across your codebase, architectural documentation, and historical agent runs. Using hybrid dense-sparse vector indexing, agents perform sub-millisecond retrieval of relevant code snippets and historical bug resolutions without polluting the active context window.

• Semantic Tool Cache: Identical read-only tool calls (such as reading unmodified source files or querying unchanging API endpoints) are cached across all agents. If Claude inspects a config file, subsequent workers can access that verified AST immediately without incurring additional I/O or token costs.

Agent Relay v2: Technical Protocol Specification

How do independent AI processes exchange execution state safely without risking prompt injection, schema corruption, or dropped variables? Agent Relay v2 implements a rigorous, typed protocol based on JSON-RPC and structured event envelopes:

• Envelope Architecture: Every handoff between agents is encapsulated in a signed envelope containing origin runtime identifiers, task IDs linking to the supervisor DAG, explicit state invariants, typed artifact payloads, and remaining token budgets.

• Fail-Safe Circuit Breakers: If a downstream worker encounters an unrecoverable exception, timeout, or repeated validation failure, the envelope is routed back to the supervisory planner with the full failure trace, enabling automatic recovery or fallback model substitution.

Dynamic DAG Planning and Supervisory Execution

Rather than relying on static scripts or unconstrained swarms, Artificial Computer executes multi-agent workflows through dynamically compiled Directed Acyclic Graphs (DAGs):

Compilation Phase: Claude parses the user's high-level objective, queries the memory graph for project context, and outputs an executable task plan structured as nodes and dependency edges.

Parallel Scheduling: Tasks without mutual dependencies (e.g. running unit tests on the backend while scraping frontend component docs) are executed in parallel across independent workers.

Barrier Synchronization: Dependent tasks wait for upstream validation gates before dispatching. If the backend tests fail, the deployment task is automatically pruned from the execution queue.

Live Human-in-the-Loop Checkpoints: For sensitive operations (e.g. database migrations, external API mutations, public Git pushes), the DAG engine halts at designated approval nodes, presenting the human supervisor with a clean diff and approval action.

Unified Agent Telemetry and Real-Time Observability

Managing multiple autonomous agents in production requires enterprise-grade observability:

• Distributed Trace IDs: Every user instruction generates a root trace ID propagated through every subtask, tool call, and agent handoff, enabling end-to-end visualization in our timeline UI.

• Token Burn Velocity: Real-time graphs visualize token expenditure per minute across OpenAI, Anthropic, and local runtimes, with configurable soft and hard spending caps.

• Loop Interception Engine: By analyzing consecutive tool call entropy and embedding distance between successive agent prompts, Artificial Computer detects infinite retry loops within three iterations, saving hundreds of dollars in wasted API fees.

Security, Sandboxing, and Isolation

Running autonomous agents that execute arbitrary code and interact with local file systems demands rigorous security architecture. Local tools and CLI processes run inside sandboxed subprocesses with strictly isolated environment variables. Sensitive credentials (API keys, database passwords) are stored in encrypted OS keychains and injected into MCP tool calls via zero-knowledge proxies—agents never see or log raw secret tokens. All outbound network calls initiated by agents are logged and filtered against workspace permission lists.

Looking ahead

This architecture blueprint solidifies Artificial’s mission: building the universal coordination layer for autonomous AI agents. We prioritize rock-solid reliability, open protocols, and zero platform lock-in.

In the coming months, we will expand multi-agent debugging tools, introduce unified agent metrics, and roll out new runtime adapters. We are actively testing these supervisory primitives with our private alpha design partners as we prepare for open preview. Discover more details on our features overview or review our pricing plans to deploy Artificial Computer across your development organization.