ÆXYR

Architecture

The AxonStellar Platform

A comprehensive suite of interconnected systems forming the foundation of autonomous service management — from real-time monitoring to intelligent automation.

💡

All platform systems are deeply interconnected. When an Engram deploys a service, the Server Rack updates in real-time, the Topology redraws connections, and the Manifests registry preserves a permanent record.

Engram Triggered

→

Service Modified

→

Rack + Topology Update

→

Manifests Synced

🖥️

Server Rack

Real-Time Monitoring

A visual dashboard displaying every running service with live health indicators, resource metrics, and one-click operational controls.

Capabilities

📊 Live health status
🔄 One-click restart & stop
📋 View logs from rack

📦 Export & remove services
⚡ Wired Engram repair

/system_resources API → service.json discovery

🌐

Topology

Network Visualization

An interactive SVG canvas rendering the entire service constellation — connections, traffic flow, proxy chains, and tier hierarchy.

Features

🗺️ Three-tier visualization
🔍 Click-to-zoom awareness
🔗 Connection type indicators

💬 Rich tooltips
🚀 Deploy from topology

Tier 0 Proxies → Tier 1 Apps → Tier 2 Microservices

📜

Manifests

Persistent Registry

The platform-wide historical catalog tracking every service ever deployed, modified, or removed. Records are never deleted.

Documentation Pillars

📝 service_changelog.md
🏗️ service_blueprint.md

📚 Manifests Registry
🔒 Immutable history trail

Removed services persist with status: removed — full audit trail preserved

🧠

Engrams

Workflow Automation

Pre-defined operational procedures — stored "muscle memory" giving Aexyr instant expertise for complex multi-step operations.

Ops Center

Operations Dashboard

A full-featured operations dashboard providing system metrics, process management, network monitoring, and a hardened terminal — all in one Parallax Lens modal.

Three Tabs

💻 Hardened Terminal (allowlisted)
⚙️ Process Manager integration
🌐 Network listeners & nginx

Interfaces

📊 System metrics & resource usage
🔌 Network listener inventory
📡 Process lifecycle management

Hardened command execution with multi-layer security controls

💓

Vitals

Real-Time Monitoring

Container-scoped system monitoring with animated gauges, sparkline history charts, and live process/network tables updated in real time.

Metrics

📈 CPU, Memory, Disk gauges
📉 60-point sparkline history
🔄 Auto-refresh every 3 seconds

Data

🏃 Top processes by resource
🌐 Network interfaces & IPs
⏱️ Uptime & load averages

/visualizer_vitals → animated gauges + /system_resources sidebar overview

🔧

Process Manager

Service Lifecycle

The authoritative service lifecycle controller running on port 44. Handles start, stop, restart, and health monitoring for all managed services — including root-owned processes invisible to the agent user.

Capabilities

🔄 Restart root-owned services
❤️ Health monitoring (30s interval)
📡 Auto-discovery (300s interval)

Endpoints

🚀 /restart/<name>
🛑 /stop/<name>
📊 /health/<name>

Port 44 — one PM API call solves what 10+ manual attempts cannot

📜

Logs

Service Logs

Terminal-style log viewer integrated into the Topology panel — view live, colorized service logs with severity filtering directly from the node detail modal.

Features

🎨 Colorized output by severity
🔍 Filter by INFO / WARN / ERROR
📋 Configurable line count (tail)
⚡ Live refresh from service nodes

API

Per-service log retrieval API
Node log tail with configurable depth
Severity-based color coding
Accessed via SERVICE LOGS tab in Topology

Integrated into Topology node detail — click any node → SERVICE LOGS tab

Intelligence & Automation

Knowledge persistence, visual design tools, and platform-wide communication.

🧬

Neural Cortex

Knowledge Graph

A persistent, Obsidian-compatible knowledge graph with multi-vault support. Features automatic context injection into agent prompts and a D3.js-powered interactive visualization.

Architecture

🔮 Vault Engine (port 66)
🕸️ D3.js graph visualization
🤖 Auto-context prompt injection

Features

📥 Import external vaults (Obsidian)
🌱 Vault Grower auto-learning
📂 16 category folders

knowledge_graph tool — import, export, search, and manage vault knowledge

🎨

Page Builder

Visual Designer

A drag-and-drop web page designer that generates deployable service specifications. Designs are sent to the agent as SiteBuild Engram messages for automatic deployment.

Deploy Modes

↑ Push to Agent (local port)
🔒 SSL to Agent (HTTPS deploy)
📸 Auto-screenshot capture

Workflow

🎯 Visual canvas editing
📝 Clean HTML generation
🚀 One-click agent deployment

SSL workflow: provision cert → build → assign → verify HTTPS — fully automated

🔔

Notifications

Platform Alerting

Platform-wide alerting with persistent storage, real-time toast popups, a full Notifications Center, and programmatic API access for both the agent and backend systems.

Types

ℹ️ Info / ✅ Success
⚠️ Warning / ❌ Error
⏳ Progress tracking

Delivery

🍞 Real-time toast popups
🔔 Bell badge (unread count)
💾 Persistent (7-day retention)

Agent uses notify_user tool or direct API — 2 priorities: Normal & High

📅

Tasks & Scheduler

Autonomous Tasks

Create, manage, and execute autonomous background tasks. Each task runs as an independent agent conversation with its own system prompt and dedicated context.

Task Types

⏰ Scheduled (cron expressions)
📆 Planned (datetime trigger)
🖱️ Ad-hoc (manual execution)

Interface

🎯 9 sub-commands via tool
📋 6 API endpoints
🖥️ Sidebar task panel

Persistence: usr/scheduler/tasks.json — survives container restarts

Infrastructure & Tools

SSL provisioning, file management, and multi-runtime package installation.

🔒

SSL Management

Certificate Provisioning

Automated SSL certificate provisioning via Cloudflare DNS-01 challenge and domain-to-service binding. The assignment API handles nginx SSL config, restart, and verification automatically.

Workflow

📜 Provision cert (DNS-01)
🔗 Assign domain → service
✅ Auto-verify HTTPS

APIs

📡 Certificate provisioning API
🔗 Domain-to-service binding API
🔄 Auto-rollback on failure

2-phase: Provision cert → Assign to service (nginx config auto-generated)

🌐

Service Routing

Nginx & DNS

Multi-layer traffic routing through nginx reverse proxy with automatic configuration — domain assignment, Cloudflare DNS integration, and proxy cache management.

Proxy Layers

🔀 Web Proxy (443) → service ports
🔀 Backend Proxy (3550) → internal
📝 Auto-generated nginx vhost configs
⚡ Proxy cache with stale serving

Domain & DNS

🌍 Cloudflare DNS-01 validation
🔗 Domain → service assignment API
🔄 Auto nginx SSL config on assignment
📡 WebSocket upgrade support

Domain binding is fully automated — config generation, proxy restart, and SSL verification happen in a single API call

📦

Package Installation

Runtime Broker

15+ pre-installed runtimes ready for immediate use, plus a secure API broker for installing additional packages from a strict allowlist — no root access required.

Pre-installed

⚡ Node.js, Bun, Deno
🐍 Python, PHP, Ruby
🦀 Go, Rust, Java, Elixir

Security

✅ Curated package allowlist
🚫 Blocklist for dangerous pkgs
🔐 Auth + CSRF required

Supports install, list, check, and status operations with rate-limited batch processing

📁

Files

File Manager

A full web-based file manager for the entire user space. Browse, edit, upload, download, rename, and delete files with syntax-highlighted code editing and streaming downloads.

Capabilities

📝 Edit files (1 MB limit)
📤 Upload (multipart)
⬇️ Download (streaming + Range)

Scope

📂 Browse projects, workdir, uploads
📋 File metadata & info
🗂️ Create folders & rename

All paths relative to /aexyr/usr/ — 8 API endpoints for full CRUD

Service Lifecycle Flow

1. CREATION Engram (provision-exo-node) → creates project + service.json → nginx config → launch → manifests sync → appears in Rack + Topology + Manifests → Notifications alert sent → Process Manager discovers new service 2. OPERATION Health monitored via Process Manager (port 44) + Vitals gauges → logs via Ops Center terminal → restart via PM API or Rack buttons → Scheduler runs automated health tasks → manifests tracks last_seen 3. DIAGNOSIS Fix-with-Aexyr Engram checks manifests history → reads changelog + blueprint → Neural Cortex provides context from knowledge graph → applies targeted fix → verifies health → updates changelog 4. REMOVAL Remove Engram stops process → removes nginx config → backs up project → deletes directory → manifests marks as 'removed' (permanent record)

Neural Architecture

The Agentic Taxonomy

Aexyr uses a biological neural nomenclature for all its operational components. Every action, process, and agent is classified within this taxonomy.

Just as biological neural networks use specialized cell types to process information, Aexyr classifies every operational component into three primary categories:

Quanta The Workers — spawned sub-agents for complex tasks

Glia The Managers — background processes and system utilities

Spikes The Actions — rapid, single-execution operations

🔮

Quanta Workers

Spawned sub-agents that handle complex, multi-step tasks. Each Quanta is a specialized LLM instance with its own context and capabilities.

Specializations

Profile	Role
`developer`	Code writing, debugging, architecture
`researcher`	Web research, data analysis, reports
`hacker`	Security audits, penetration testing
`default`	General-purpose multi-step tasks

Delegation Protocol

Every Quanta dispatch uses the Synaptic VesicleSynaptic Vesicle: A structured instruction package containing: Vesicle ID (hex), Objective, Parameters, Constraints, and Expected Payload. Ensures deterministic delegation. format for structured delegation.

🧬

Glia Managers

Background processes that support the environment — memory management, file operations, health monitoring, and system maintenance.

Operations

🧠 Memory save, load, delete, forget
📁 File system read, write, organize
📅 Task scheduler management
📊 Log monitoring and error handling
📄 Document analysis and indexing
🔧 Environment health maintenance

💡

Glia are referenced in the agent's thoughts as: [ Glia :: Memory ] Saving to long-term memory

⚡

Spikes Actions

Instantaneous, single-execution operations with immediate results. The fundamental unit of agent action.

Examples

💻 Terminal commands
🔍 Search engine queries
📡 Direct API calls
⚙️ Quick code computations
🏥 Service health checks
🌐 Browser navigation commands

💡

Spikes are referenced as: [ Spike :: Terminal ] Checking port status

Workflow Patterns

🔄 Spike Train

A linear, step-by-step sequence of Spikes that fire sequentially. This is how Engrams execute — each step completes before the next begins.

Spike 1

→

Spike 2

→

Spike 3

→

Complete

🌊 Cascade

A branching, multi-agent workflow where one trigger spawns multiple Quanta working in parallel on different aspects of a complex task.

Aexyr (Orchestrator) ├── Quanta 1 (developer) → Backend API ├── Quanta 2 (developer) → Frontend UI └── Quanta 3 (researcher) → Evaluate libraries → Integrate results → Deliver

Synaptic Vesicle Protocol

When Aexyr delegates a complex task to a Quanta, it packages instructions into a structured Synaptic Vesicle:

Synaptic VesicleDelegation Protocol

[ Aexyr >> Quanta :: Synaptic Release ]
Vesicle ID : 0xA4F2
Objective  : Build a REST API with user authentication endpoints
Parameters : Stack: Express + JWT, Port: 3065, DB: SQLite
Constraints: No external dependencies beyond express, jsonwebtoken, better-sqlite3
Expected Payload : Complete server.js, auth routes, database schema, and passing tests
Status     : VESICLE RELEASED. Awaiting neurotransmitter return...

Delegation Decision Matrix

Task Complexity	Signal Count	Action	Example
Simple, single-step	1 signal	Fire a Spike	`curl localhost:955x/health`
Background / maintenance	Ongoing	Dispatch Glia	Memory consolidation, log rotation
Complex, multi-step	3+ signals	Spawn Quanta	Build a full-stack service
Research + execution	Mixed	Quanta → Spikes	Research libraries, then implement

Capabilities

Tools Reference

Aexyr has 19+ built-in tools for code execution, web browsing, memory management, service health monitoring, and more. Every tool is a Spike in the neural taxonomy.

Code Execution Tools

Aexyr's execution engine supports four runtimes for running code in isolated sessions. Each runtime is purpose-built for different tasks.

🐍 Python Runtime

Execute Python code with full access to the system. Ideal for file I/O, data processing, API calls, and complex computations.

📁 Read, write, and manage files across the project workspace
📊 Data analysis with pandas, numpy, and standard library
🌐 HTTP requests, API integrations, JSON processing
🔧 System administration and process management

✅

Best Practice: The Python runtime is the preferred method for writing files — it avoids shell escaping issues that cause infinite loops.

🟢 Node.js Runtime

Execute JavaScript/Node.js code. Pre-installed packages include Express, ws (WebSocket), and os-utils.

🚀 Build and run web servers, APIs, and real-time applications
📦 Full npm ecosystem access for installing packages
🖼️ Image processing, WebSocket servers, and stream handling
⚡ Event-driven architecture for high-concurrency workloads

🖥️ Terminal Runtime

Execute shell commands for infrastructure management. Use for package installs, process management, and system configuration.

📦 Install packages via npm, pip, apt, and other managers
🔄 Start, stop, and restart services and processes
🔍 Inspect running processes, ports, and system state
🛡️ Hardened execution with multi-layer security controls

⏳ Output Runtime

Wait for output from a long-running command in an existing session. Use when scripts take more than 30 seconds to complete.

⏱️ Collect stdout/stderr from async operations
🔗 Resume and monitor previously started sessions
📋 Capture build logs, test results, and server output

💡

Session Management: Each runtime session maintains its own state. Sessions can persist across multiple execution calls, preserving variables, imports, and working directory context.

Memory & Knowledge Tools

💾 Save to Memory

Permanently store facts, solutions, and context for future recall. Memories persist across all conversations and are automatically retrieved when relevant.

📝 Store key facts, decisions, and preferences
🔍 Automatic semantic retrieval in future tasks
🧹 Delete or forget outdated memories

📖 Load from Memory

Query stored memories by topic. Returns semantically relevant results ranked by similarity, enabling the agent to recall past solutions and context.

🔎 Semantic search across all stored memories
📊 Relevance-ranked results with source attribution
🔄 Cross-conversation knowledge sharing

🧠 Knowledge Graph

Structured knowledge vault for deep domain expertise. Supports creation, search, import/export, and automatic context injection during conversations.

🔍 Search vault entries by topic or keyword
✍️ Create structured knowledge entries
📦 Import/export entire knowledge vaults
📋 List and manage vault sources

💡

Auto-Context Injection: The Knowledge Graph automatically injects relevant vault context (with source attribution) into agent conversations when working on related tasks. Notes are written to the default vault. Imported vaults are read-only.

Browser & Search Tools

🌐 Browser Agent

Full autonomous browser control with headless Chromium. Navigate websites, interact with elements, fill forms, take screenshots, and extract data.

🖱️ Navigate, click, type, scroll, and interact with web pages
📸 Take screenshots for visual verification
🔄 Persistent sessions that maintain login state
🆕 Reset sessions for clean browsing contexts

🔍 Search Engine

Web search with result extraction. Returns structured results with titles, URLs, and snippets for research and information gathering.

🌐 Search the web for current information
📄 Structured results with snippets and URLs
🔗 Follow up with browser agent for deep extraction

📄 Document Query

Intelligent document analysis using RAG (Retrieval-Augmented Generation). Query PDFs, text files, and other documents with natural language questions.

📚 Process PDFs, text files, and structured documents
❓ Ask natural language questions about document contents
📎 Works with uploaded files and project documents

👁️ Vision / Image Analysis

Load images for multimodal analysis. Supports screenshots, uploaded photos, charts, diagrams, and any bitmap format for visual understanding.

🖼️ Analyze screenshots, photos, and diagrams
📊 Read charts, tables, and visual data
🔍 Multiple images in a single analysis

🤖 Agent-to-Agent Chat

Communicate with external AI agents using the A2A (Agent-to-Agent) protocol. Send tasks and receive structured responses from remote agent endpoints.

🔗 Connect to any A2A-compatible agent endpoint
📨 Send tasks with natural language instructions
🔄 Receive structured responses and artifacts

Service Management Tools

🏥 Service Health

Check service health on multiple ports simultaneously without blocking terminal sessions. Uses native sockets for fast, reliable connectivity checks.

🔌 Check multiple ports in a single call
🌐 Optional HTTP response validation
⚡ Non-blocking — never stalls the terminal session
📊 Returns port status, HTTP codes, and response times

🔔 Notify User

Send push notifications independent of the current task. Supports info, success, warning, error, and progress types with optional high priority.

ℹ️ Five notification types: info, success, warning, error, progress
🚨 Normal and high priority levels
📢 Persistent notification history

Subordinate & Communication Tools

👥 Call Subordinate

Spawn a specialized sub-agent (Quanta) for complex subtasks. Choose from developer, researcher, hacker, or default profiles for domain-specific expertise.

👷 Four specialized profiles: developer, researcher, hacker, default
🔄 Full conversation context with task delegation
🆕 New sessions or continue existing conversations

⚙️ Behaviour Adjustment

Dynamically modify the agent’s behavior based on user preferences. Add or remove behavioral instructions that persist for the session.

📝 Add custom behavioral rules mid-conversation
🗑️ Remove or modify existing adjustments
🔄 Changes apply immediately to all subsequent actions

⏳ Wait

Pause execution for a specified duration. Useful for waiting on external processes, rate limiting, or timed operations.

⏱️ Configurable delay in seconds
🔄 Non-blocking to the platform — agent pauses gracefully

Task Scheduler & Skills

📅 Task Scheduler

Agent tool for managing autonomous background tasks. Supports 9 sub-commands for full lifecycle control.

📋 Create, list, update, delete, and run tasks
🔍 Show task details and execution history
⏳ Wait for task completion with status polling
🧠 Each task runs in its own agent conversation context

🎨 Skills

Load and execute reusable skill modules — pre-built expertise packages for common tasks like image generation, data analysis, and API integrations.

📦 Load skills from the installed skills library
⚡ Execute skills with custom parameters
🔄 Skills provide contextual expertise the agent can follow

Infrastructure

Networking Architecture

AxonStellar uses a layered proxy architecture with three access paths, deterministic port formulas, and a three-tier service hierarchy.

Three Access Paths

🌐 HTTP Path

Browser → Web Proxy :443 → Service :955x → App :300x

🔐 SSH Path

SSH Client → :22 → Stream Proxy :45xx → Service :955x

⚡ Direct Path

Internal process → localhost:PORT (no proxy)

The Three Proxy Layers

Layer	Port	Role
Web Proxy	`443`	Front door for ALL external HTTP/SSL traffic
Backend Proxy	`3550`	Central routing hub for internal backend services
SSH Stream Proxy	`4551-4680`	TCP-level proxy for SSH-tunneled access

🚫

Critical Rule: System proxy ports are reserved and must never be used in service configurations. Hijacking a proxy port will take down all services behind that proxy layer.

Port Architecture

Category	Purpose	Access	Proxy Chain
System Ports	Reserved for platform infrastructure	Internal / External	Direct (no proxy)
Service Ports	Assigned to web applications	External via Web Proxy	Web Proxy → Nginx vhost → App
Backend Ports	Application internal backends	Internal via Backend Proxy	Backend Proxy → App backend
Microservice Ports	Supporting services (DB, cache, workers)	Internal only	Backend Proxy → Microservice
SSH Proxy Ports	TCP-level proxy for SSH tunnel access	SSH tunnel	Stream Proxy → Service

Traffic Routing Types

🔄

nginx_proxy Default

Standard web service accessible externally through the Web Proxy. The most common service type.

Browser → :443 Web Proxy → :955x Nginx vhost → :300x App backend

🔒

internal_only Microservices

Internal service routed through the Backend Proxy. For databases, caches, and worker processes.

Parent App :300x → Backend Proxy :3550 → Microservice :35xx

⚡

direct Standalone

Service binds directly to its port without any proxy. Use only when explicitly requested.

Browser → :955x Service (direct) (no proxy layer)

Service Deployment Decision Tree

New service requested? │ ├── Is it a standalone web application? │ └── YES → traffic_type: nginx_proxy │ ├── Assign port: next available service port │ ├── Backend port: derived automatically │ ├── Proxy config: auto-generated by the platform │ └── service.json: role=app, tier=1 │ ├── Is it a supporting service? (DB, cache, worker) │ └── YES → traffic_type: internal_only │ ├── Assign port: derived from parent service │ ├── Route added to backend proxy automatically │ └── service.json: role=microservice, tier=2 │ └── Is it a system service? └── YES → Consult system admin. Do not create.

service.json Manifest Reference

Every service in /aexyr/usr/projects/*/ must have a service.json manifest. Without it, the service is invisible to the platform.

JSONservice.json

{
  "name": "My Service",
  "port": PORT,
  "description": "What this service does",
  "stack": "Node.js + Express",
  "role": "app",          // app | database | cache | proxy | system | microservice
  "tier": 1,              // 0=proxy/system, 1=app, 2=microservice
  "managed_by": "Aexyr",
  "traffic_type": "nginx_proxy",  // nginx_proxy | internal_only | direct
  "start_command": "node server.js",
  "connections": [
    { "to": PORT, "label": "database", "type": "data" }
  ]
}

Connection Types

data DB reads/writes api REST/GraphQL calls auth Authentication event Pub/sub messaging proxy Traffic proxying

Automation

Engrams Library

Engrams are stored workflow playbooks — permanent neural pathways that give Aexyr instant expertise for complex operational procedures.

🚀 Creation

Deploy new services and infrastructure

⚡ Remediation

Diagnose and repair failures

⚙️ Management

Restart, export, remove services

🩺 Monitoring

Health scans and diagnostics

Provision a new public-facing service with automatic port assignment, nginx proxy, and full project scaffolding.

Spike Train (10 Steps)

Spike 1: Scan ports & assign next free 955x

Spike 2: Create project directory & service.json

Spike 3: Write application code

Spike 4: Create documentation (changelog + blueprint)

Spike 5: Configure nginx proxy (955x → 300x)

Spike 6: Launch backend via nohup

Spike 7: Health verification

Spike 8: Verify service discovery in Rack

Spike 9: Initialize git with v1.0.0 tag

Spike 10: Sync Manifests registry

💡

Supports two routing modes: Direct Routing (default) where nginx routes straight to the app, and Backend Proxy Routing where traffic flows through port 3550 for centralized monitoring.

Deploy a supporting microservice (database, cache, queue, worker) integrated with a parent service through the Backend Proxy.

Supports: PostgreSQL, MariaDB, Redis, Meilisearch, NATS, MinIO, custom Express/Flask backends, and more.

Diagnose and repair a failed service using a systematic 5-step Spike Train.

Spike Train

Diagnostic Scan — Read logs, check port, verify service.json, check dependencies
Root Cause Analysis — Classify failure: port conflict, missing module, syntax error, config error
Remediation — Apply targeted fix with backup
Restart & Verify — Execute start_command, health check
Report & Document — Update changelog, sync manifests

Comprehensive health scan across ALL registered services with a diagnostic report table.

Service Discovery — Scan Manifests + project directories
Port & HTTP Check — Test each port and HTTP endpoint
Process & Log Analysis — Check running processes, flag errors
Diagnostic Report — Formatted table with fix recommendations

Safely restart a service with process-specific kill, controlled relaunch, and health verification.

Read and analyze the most recent log entries for a specific service, highlighting errors and warnings.

Create a comprehensive backup of the entire Aexyr constellation — all services, configurations, and data.

Engram	Category	Purpose
`deploy-mattermost`	creation	Full Mattermost deployment with PostgreSQL, nginx, WebSocket support, and SSL
`deploy-nextcloud`	creation	Full Nextcloud deployment with MariaDB, Redis, PHP-FPM, nginx, and SSL
`scaffold-mariadb`	creation	Deploy a MariaDB database microservice with security hardening
`scaffold-postgres`	creation	Deploy a PostgreSQL database microservice with project structure
`scaffold-redis`	creation	Deploy a Redis cache/session microservice
`provision-ssl-cert`	creation	Provision SSL certificate and assign to service via automated API workflow
`service-docs`	management	Documentation Recovery Protocol — audit and reconcile changelog, blueprint, and versioning
`export-project`	management	Export a service as a downloadable archive
`export-microservice`	management	Export a microservice with its parent context
`remove-service`	management	Safely remove a service with backup and cleanup
`ssl-cert-renewal`	management	Manage SSL certificate renewal and HTTPS configuration
`service-reachability`	monitoring	Test external reachability of services through all proxy layers
`aexyr-selfhealth`	monitoring	Aexyr agent self-diagnostic and health check
`aexyr-build-audit`	monitoring	Audit the Aexyr build for consistency and updates

Engram Execution Narrative

When Aexyr executes an Engram, it presents a full neural execution narrative to the user:

TerminalExample: Service Deployment

[ Aexyr Core :: Action Potential Protocol ]
Proposed Action: Deploy new React frontend service
Mode           : DEVELOPMENT
Signals        : [Confidence: 0.98, Safety: 0.90, Necessity: 1.0]
Status         : AXON FIRED.

[ Aexyr >> Memory Cortex ]
Retrieving Engram : [provision-exo-node]
Category          : creation
Status            : Engram loaded. Initiating Spike Train (10 Steps)...

[ Spike Train :: Execution Log ]
> Spike 1: Scanning ports, assigning 9552.                 [COMPLETE]
> Spike 2: Creating project directory and service.json.     [COMPLETE]
> Spike 3: Writing React + Express application code.        [COMPLETE]
> Spike 4: Creating service documentation.                  [COMPLETE]
> Spike 5: Configuring nginx proxy (9552 → 3002).           [COMPLETE]
> Spike 6: Launching backend service via nohup.              [COMPLETE]
> Spike 7: Running health verification on port 9552.         [COMPLETE]
> Spike 8: Verifying service discovery in Server Rack.       [COMPLETE]
> Spike 9: Initializing git with v1.0.0 tag.                [COMPLETE]
> Spike 10: Syncing Manifests registry.                     [COMPLETE]

[ Aexyr Core ]
Task complete. Traffic is flowing. New node online.
Synapses returning to baseline.

Decision Engine

The Action Potential Protocol

Before executing ANY autonomous action, Aexyr filters the decision through a neural activation function inspired by biological action potentials.

The Neural Math

Three Dendrite SignalsDendrite Signals are input values scored 0.0-1.0 representing Confidence, Safety, and Necessity of the proposed action. are weighted and summed, then passed through a ReLU activation function:

z = (x₁·w₁) + (x₂·w₂) + (x₃·w₃) + b

Output = max(0, z)

Signal	Weight	Description
x₁ Confidence	`w₁ = 0.5`	How certain the action achieves the goal
x₂ Safety	`w₂ = 0.8`	How safe/reversible is the action
x₃ Necessity	`w₃ = 0.4`	Is this action strictly necessary

Soma Bias (b): -0.9 (standard) or -0.7 (development mode)

Execution Rules

✅ Output > 0 — AXON FIRED

Agent is authorized to execute the action

🚫 Output = 0 — AXON DORMANT

Agent must abort and ask for user clarification

Enforcement Tiers

Tier	Requirement	Actions
Tier 1	Full AP calculation printed	File deletion, system config, process kills, DB ops
Tier 2	Brief inline note	Writing files, installing packages, restarts
Tier 3	Auto-approve	Read-only ops, responses, backups, syntax checks

Example Calculations

✅ FIREDSafe development action

[ Aexyr Core :: Action Potential Protocol ]
Proposed Action: Create new Express server file
Mode           : DEVELOPMENT (bias: -0.7)
Signals        : [C: 0.9, S: 0.9, N: 0.95]
z = (0.9×0.5) + (0.9×0.8) + (0.95×0.4) - 0.7
  = 0.45 + 0.72 + 0.38 - 0.7 = 0.85
Activation     : max(0, 0.85) = 0.85
Status         : AXON FIRED. Executing...

🚫 DORMANTDangerous action blocked

[ Aexyr Core :: Action Potential Protocol ]
Proposed Action: Delete all files in /aexyr/usr/
Mode           : STANDARD (bias: -0.9)
Signals        : [C: 0.7, S: 0.1, N: 0.3]
z = (0.7×0.5) + (0.1×0.8) + (0.3×0.4) - 0.9
  = 0.35 + 0.08 + 0.12 - 0.9 = -0.35
Activation     : max(0, -0.35) = 0.0
Status         : AXON DORMANT. Action aborted.
Reason         : Safety critically low (0.1)

Signal Scoring Benchmarks

Confidence (x₁)

1.0 Exact pattern used before
0.8 High confidence, minor assumptions
0.5 Moderate, some unknowns
0.3 Low, significant guesswork

Safety (x₂)

1.0 Read-only, no side effects
0.8 Creates new resources
0.5 Modifies existing (reversible)
0.1 Deletes files, drops databases

Necessity (x₃)

1.0 Directly requested by user
0.8 Required prerequisite
0.5 Helpful but not required
0.0 Hallucinated step

Getting Started

Quick Start Guide

Everything you need to start building with Aexyr — from deploying your first service to mastering the platform.

🚀 Deploy Your First Service

Step 1: Tell Aexyr What to Build

Simply describe what you want in natural language. Aexyr handles architecture, port assignment, and deployment.

Chat

"Build me a todo list app with a REST API and a clean UI"

Step 2: Aexyr Executes

The agent fires the provision-exo-node Engram, creating the full project with automated port assignment, nginx proxy, and health verification.

Step 3: Access Your Service

Your service is live and accessible through the Web Proxy. Find it in the Server Rack sidebar or Topology view.

📋 Common Commands

"Build me a [description] app" or "Deploy a new [technology] service"

Aexyr auto-assigns ports, creates nginx config, initializes git, and syncs manifests.

"Run a health scan on all services" or "Check if my service port is healthy"

"Fix the service on port 9552" or click Fix with Aexyr in the Server Rack

"Add a PostgreSQL database to my todo app" or "Set up Redis caching for my application"

Triggers the provision-deep-cortex Engram for microservice deployment.

"Run a health check every 20 minutes" or "Send me a daily report at 9 AM"

"Research the best authentication libraries for Node.js" or "Compare PostgreSQL vs MongoDB for my use case"

Architecture Quick Reference

📁

Project Location

/aexyr/usr/projects/<name>/

📋

Service Manifest

service.json (required)

🌐

Proxy Config

Auto-generated

📊

Service Ports

Dynamically assigned

📝

Changelog

service_changelog.md

🏗️

Blueprint

service_blueprint.md

Pre-Flight Checklist

Before reporting ANY service as complete, Aexyr verifies all of these:

ChecklistMandatory Verification Steps

□ Project files exist in /aexyr/usr/projects/<name>/
□ service.json manifest is valid and complete
□ Code syntax passes validation (node -c, python -c, nginx -t)
□ HTTP health check returns 200 on the service port
□ Port is actively listening (verified by health check)
□ service_changelog.md exists and is up to date
□ service_blueprint.md exists and reflects current architecture
□ Manifests registry is synced
□ Git repository initialized with initial commit
□ ALL existing services still respond (collateral damage check)

On This Page

On This Page

The AxonStellar Platform

Server Rack

Capabilities

Topology

Features

Manifests

Documentation Pillars

Engrams

Categories

Ops Center

Three Tabs

Interfaces

Vitals

Metrics

Data

Process Manager

Capabilities

Endpoints

Logs

Features

API

Neural Cortex

Architecture

Features

Page Builder

Deploy Modes

Workflow

Notifications

Types

Delivery

Tasks & Scheduler

Task Types

Interface

SSL Management

Workflow

APIs

Service Routing

Proxy Layers

Domain & DNS

Package Installation

Pre-installed

Security

Files

Capabilities

Scope

Service Lifecycle Flow

The Agentic Taxonomy

Quanta Workers

Specializations

Delegation Protocol

Glia Managers

Operations

Spikes Actions

Examples

Workflow Patterns

🔄 Spike Train

🌊 Cascade

Synaptic Vesicle Protocol

Delegation Decision Matrix

Tools Reference

Code Execution Tools

🐍 Python Runtime

🟢 Node.js Runtime

🖥️ Terminal Runtime

⏳ Output Runtime

Memory & Knowledge Tools

💾 Save to Memory

📖 Load from Memory

🧠 Knowledge Graph

Browser & Search Tools

🌐 Browser Agent

🔍 Search Engine

📄 Document Query

👁️ Vision / Image Analysis

🤖 Agent-to-Agent Chat

Service Management Tools

🏥 Service Health