Autonomous Agent Transitions in AgenticOS: From Simple Automation to Self-Improving Systems

Autonomous Agent Transitions in AgenticOS

AgenticOS introduces a revolutionary capability: Agent Transitions – transitions powered by LLMs that can reason, query, create structures, and even deploy new transitions autonomously. This guide explores the full spectrum of agent capabilities, from simple token processing to self-improving meta-agents.

Agent Transition: LLM-Powered Automation tasks NL instructions memory AGENT 🧠 LLM reasoning loop results new-nets transitions Available Tools QUERY_TOKENS CREATE_TOKEN CREATE_NET CREATE_PLACE LIST_ALL_SESSIONS EMIT_MEMORY DEPLOY_TRANSITION START_TRANSITION … and more

The Role Hierarchy

Agent transitions operate under a role-based access control system. Each role grants access to more powerful capabilities, building on the previous level.

Role Hierarchy: Capabilities Build Upward READ_ONLY QUERY_TOKENS, LIST_PLACES, GET_PLACE_INFO, GET_TRANSITION, GET_NET_STRUCTURE 7 tools TOKEN_RW + CREATE_TOKEN, DELETE_TOKEN 9 tools STRUCTURE_CREATE + CREATE_NET, CREATE_PLACE, CREATE_TRANSITION, CREATE_ARC, SET_INSCRIPTION, HTTP_CALL 15 tools META_AGENT + LIST_ALL_SESSIONS, LIST_ALL_INSCRIPTIONS, LIST_SESSION_NETS, EMIT_MEMORY 19 tools META_AGENT_AUTONOMOUS + DEPLOY_TRANSITION, START_TRANSITION, STOP_TRANSITION 22 tools More Power Query only Standard work Build nets Discover + Create Full Autonomy

Basic Agent Inscription

At its simplest, an agent transition reads natural language instructions from a token and executes them using available tools.

{
  "id": "t-processor",
  "kind": "agent",
  "presets": {
    "task": {
      "placeId": "p-tasks",
      "host": "user-leo@localhost:8080",
      "arcql": "FROM $ LIMIT 1",
      "take": "FIRST",
      "consume": true
    }
  },
  "postsets": {
    "result": {
      "placeId": "p-results",
      "host": "user-leo@localhost:8080"
    }
  },
  "action": {
    "type": "agent",
    "role": "TOKEN_RW",
    "nl": "@task.data.instruction"
  },
  "emit": [
    { "to": "result", "from": "@response", "when": "success" }
  ],
  "mode": "SINGLE"
}

The nl field uses expression syntax to read the instruction from the bound token’s data. The agent will execute tools iteratively until it calls DONE or FAIL.


The Agent Execution Loop

Unlike other transitions that fire once, agent transitions run an iterative conversation loop with the LLM until completion.

Agent Execution Loop System Prompt Role + Tools + Context LLM 🧠 Parse Response Extract tool + params Terminal? Execute Tool QUERY, CREATE, etc. Build Result Tool output → msg DONE / FAIL Emit result No Yes Max 50 iterations (configurable) Prevents infinite loops

META_AGENT: Discovery + Creation

The META_AGENT role adds model-wide visibility – the agent can discover sessions, nets, and transitions across the entire model. But there’s a twist: access is controlled by a memory place.

Permission by Memory

The agent can only access resources mentioned in its memory tokens. This creates a secure, self-documenting permission system.

Memory = Permissions Memory Place p-agent-memory Self-Created Token { “type”: “created”, “resourceType”: “transition”, “resourceId”: “t-my-new” } Access Grant Token { “type”: “access-grant”, “sessionId”: “external-data”, “grantedBy”: “user-leo” } META_AGENT 🧠 Reads memory t-my-new ✓ external-data ✓ other-session ✗ t-unknown ✗ ● Self-created – Agent auto-emits when it creates resources ● Access-grant – Human adds to expand agent’s scope

Summary

  • Agent transitions are LLM-powered, running an iterative tool-calling loop
  • 5 roles from READ_ONLY (7 tools) to META_AGENT_AUTONOMOUS (22 tools)
  • Permission by memory – agents only access resources in their memory tokens
  • Auto-emit – creating resources automatically adds memory tokens
  • Flexible context – session/model can come from inscription, metadata, or tokens
  • Self-improving systems – META_AGENT_AUTONOMOUS can create, deploy, and start new transitions

Agent transitions represent the pinnacle of AgenticOS automation – intelligent, self-improving agentic processes that can reason about and extend themselves.

Leave a Reply

Your email address will not be published. Required fields are marked *