PROTO.
SELF-DESIGNING AGENTS
Agents that architect themselves.
Proto agents don't follow flowcharts you drew. They autonomously generate their own topology, spawn sub-agents, synthesize tools at runtime, and persist knowledge across missions. You define the goal. The agent designs everything else.
Self-Designing
Protocol
.
Proto agents design themselves. They autonomously generate their own topology, spawn sub-agents for parallel and sequential work, synthesize tools they need at runtime, and persist structured knowledge across missions. Not a flowchart. Not a script. An intelligence that architects itself for the task at hand.
The Agentic Loop — Four-Phase Autonomous Cycle
Every Proto runs a continuous observe-reason-act cycle. It evaluates the situation at each turn and decides what to do next. Observe: read your data, build a mental model of reality. Reason: classify, prioritize, make judgment calls. Act: execute operations, create records, call APIs. Iterate: check if the mission is complete, then loop back with updated state.
Adaptive
Autonomy
Agents loop until the mission is complete or a human intervenes
Capability Modules
Auto Topology
Self-generating agent topology. Proto decomposes missions into vertical (depth) and horizontal (breadth) sub-agents, then coordinates them to completion.
Runtime Tool Synthesis
When an agent encounters a task that requires a tool that doesn't exist, it writes one at runtime in the sandbox, tests it, and executes it immediately.
Knowledge Graph Memory
Hierarchical memory system: short-term working memory for the current mission, long-term structured knowledge graph that persists across missions.
Multi-Agent Coordination
Parent agents monitor sub-agent progress, merge results, resolve conflicts, and dynamically reassign work if a sub-agent gets stuck or discovers new scope.
Self-Programming
Proto agents write their own code: domain fuzzers, validators, data transformers, scoring functions. All generated, tested, and deployed at runtime.
720+ App Fabric
Full access to the ERP.AI business app suite: ERP, CRM, HR, Accounting, Inventory, MRP, and hundreds more. Every app is an API the agent can call.
Human Override
Configurable human-in-the-loop gates for high-risk actions. Agents pause for approval, then resume exactly where they left off. Full RBAC controls.
Sandboxed Everything
Every tool synthesis, code execution, and external call runs in an isolated sandbox. Failed actions trigger self-recovery, not data corruption.
Full Topology Trace
Complete observability into every agent, sub-agent, tool call, memory read/write, and decision. Full replay and audit trail for every mission.
Self-Generating Topology .
Dynamic tool synthesis at runtime.
Topology Engine T1
Proto decomposes missions into sub-agents: vertical chains for sequential reasoning, horizontal branches for parallel throughput. The topology adapts mid-mission as new scope is discovered.
Status: Self-generatingTool Synthesis S2
When an agent needs a tool that doesn't exist, it writes one: Python functions, validators, scoring algorithms. Generated in the sandbox, tested against cases, deployed instantly.
Status: Runtime activeMemory Graph M3
Short-term working memory for the current mission. Long-term knowledge graph that persists across missions. Agents recall past strategies, templates, and domain patterns.
Status: PersistingCoordination Layer C4
Parent agents monitor sub-agent progress, merge results, resolve conflicts. Dead sub-agents are replaced. Scope changes trigger new topology branches dynamically.
Status: Coordinating05 Deploy agents in minutes
A single API call spins up an autonomous agent with a mission, app access, budget caps, and human-approval gates. No SDKs to install, no infra to manage.
# Deploy an autonomous Proto agent
curl -X POST https://api.erpai.com/v1/proto/deploy \
-H "Authorization: Bearer $ERPAI_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"mission": "Collect all overdue invoices over $5K, classify by risk, draft follow-up emails, escalate high-value accounts to account managers",
"apps": ["invoicing", "crm", "email"],
"budget_tokens": 50000,
"human_approval": ["escalate", "send_email"],
"memory": "persistent",
"sandbox": true
}'
# Response
# {
# "proto_id": "PRT-8841",
# "status": "running",
# "topology": "auto-generating",
# "agents_spawned": 0,
# "trace_url": "https://app.erpai.com/trace/PRT-8841"
# }* Requires an ERP.AI API key. Free tier includes $10K in credits.
How Proto Works
KPIs & success criteria
Approval gates
Scope restrictions
Retry strategies
Fallback chains
Sub-10ms Everything
Proto's runtime is written entirely in Rust. Zero-cost abstractions, no garbage collector, no runtime overhead. Every critical path — GNN inference, message passing, graph traversal, sandbox isolation — runs in single-digit milliseconds.
Single observe-reason-act-iterate cycle. Hot path through the scheduler. No heap allocation.
Full forward pass through GraphSAGE encoder. 3 message-passing rounds, d=128, batched.
Knowledge graph query over 42K nodes. Embedding similarity search + BFS path resolution.
MLP classifier on all candidate node pairs. Sigmoid scoring + topological sort for DAG output.
Sub-agent creation including RBAC check, memory allocation, topology registration, and first tick.
Spin up WASM sandbox for tool synthesis. Memory-safe isolation via Wasmtime. Zero cold-start.
Structured log with GNN attention weights, token cost, agent state. Async write to trace DB.
Full DAG reconstruction on scope change. Re-runs GNN planner, reassigns sub-agents, re-budgets tokens.
Async multi-threaded agent scheduler. Work-stealing executor. Lock-free message channels between agents.
Native Rust tensor ops. SIMD-vectorized message passing. Parallel neighbor aggregation via Rayon thread pool.
In-memory adjacency lists + HNSW embedding index. Persistent storage via Sled embedded DB. Zero-copy reads.
WASM-based tool synthesis sandbox. Capability-based security. Memory-safe isolation without process fork overhead.
Async HTTP/2 client for all 720+ API calls. TLS 1.3 via Rustls. Connection pooling + automatic retry.
Lock-free ring buffer for structured traces. Async flush to persistent store. Zero-allocation hot path.
Agent Topology DAG
Proto decomposes a mission into a directed acyclic graph of sub-agents. Each node is autonomous. Parent nodes coordinate, leaf nodes execute. Failed branches trigger self-recovery.
NLP extraction of task nodes from natural-language mission. Entity recognition + dependency parse.
N task nodesEach task node encoded to d=128 feature vector. Includes API affinity, complexity score, RBAC level.
X ∈ R^(N×128)Construct initial adjacency from task dependencies. KNN over embedding space adds latent edges.
A ∈ R^(N×N)3-round GraphSAGE aggregation. Neighbor sampling K=10. Attention-weighted mean pooling per hop.
H^(3) = GNN(X, A)MLP edge classifier on concatenated node pairs. Predicts data-flow probability + estimated token cost per edge.
Ê = σ(MLP)Topological sort + cycle removal. Final agent DAG with edge weights, token budgets, and spawn order.
Agent DAG · O(N log N)Cost Attribution Flow
Every operation has a deterministic token cost. Tokens flow from budget allocation through category multipliers to final attribution. No hidden fees, no surprises.
Hierarchical State & Knowledge
Three-tier memory system. Working memory for the current step, session memory for the mission, and a persistent knowledge graph that learns across runs.
Per-step scratchpad. Holds current API response, parsed data, intermediate calculations. Garbage-collected after each ORAI cycle.
Mission-scoped context. Accumulated observations, reasoning traces, decision log. Shared across all agents in the topology. Persists until mission completes.
GNN-powered knowledge graph. GAT attention over entity embeddings. Learns relationship weights across missions. GNN re-trains on each completed run.
Learned: batch POST faster than sequential. Saved 40% tokens on subsequent runs.
12,400 tkn → 7,440 tknLearned: API rate limit at 100/min. Auto-throttle pattern stored in L3.
8,200 tkn → 6,150 tknLearned: pre-validate tax IDs before submission. Eliminated 90% of retries.
22,000 tkn → 13,200 tknLearned: cache GL balances for 5min. Re-used across 3 sub-agents.
15,600 tkn → 9,360 tknLearned: fuzzy match threshold 0.85 optimal. Stored as domain heuristic.
5,800 tkn → 3,480 tknLearned: warehouse A ships 2x faster. Re-routed fulfilment topology.
18,900 tkn → 11,340 tknLearned: SOC2 evidence format. Template stored in L3. 60% faster generation.
31,000 tkn → 12,400 tknLearned: close subsidiaries in dependency order. Graph edge weights from L3.
42,000 tkn → 25,200 tknBuilt-In Guardrails
Hard cap on tokens consumed per mission. Agent halts at limit.
All tool calls isolated. Automatic rollback on failure.
Configurable approval checkpoints for high-stakes actions.
Every decision logged. Exportable to compliance systems.
Deploy Agents That
Design Themselves.
Define the mission. Proto architects the rest.
9 capability modules · 720+ app integrations · Full topology trace · Human override gates