Appearance

SILVIA Core LIVE CLI Reference ​

Version: 3.1

The Conversational AI Authoring Revolution ​

The Innovation: Multi-Agent ChatOps for Brain Development ​

SILVIA LIVE CLI isn't just a command-line interface. It's a modern Human-To-Machine Groupchat system where Deterministic AI, LLM AI, and Human collaborate in real-time to author, debug, and deploy AI brains.

Traditional AI Development Workflow ​

The "Old School" Method
┌───────────────────────┐
│ 1. Write code in IDE  │
│ 2. Compile            │
│ 3. Deploy             │
│ 4. Test               │
│ 5. Find bug           │
│ 6. Go back to step 1  │
└───────────┬───────────┘
            ↓

 SLOW, TEDIOUS, ISOLATED

SILVIA LIVE CLI Workflow ​

SILVIA LIVE Chat + LLM Agent:
┌──────────────────────────────────────────────┐
│ You:     "Show me the greeting behavior"     │
│ SILVIA:  [Returns behavior data]             │
│ LLM:     "I see it's missing error handling" │
│ You:     "@LLM fix it"                       │
│ LLM:     [Modifies behavior via CLI]         │
│ SILVIA:  [Confirms change]                   │
│ You:     "Test greeting"                     │
│ SILVIA:  "Hello there!"                      │
└──────────────────────┬───────────────────────┘
                       ↓

       FAST, COLLABORATIVE, CONVERSATIONAL

This is ChatOps for AI brain development - but with THREE intelligent agents working together.

Multi-Agent Addressing System ​

AI Groupchat Protocol ​

The CLI implements a message routing system where commands can be addressed to specific agents:

@SILVIA  → Routes to deterministic AI
@LLM     → Routes to language model AI  
@Human   → Routes to human operator
[none]   → Broadcast to all

Example Conversation:

You:     "status"
SILVIA:  "Core active, 1,247 behaviors loaded, live mode: ON"

You:     "@LLM analyze the greeting behaviors"
LLM:     "I found 12 greeting behaviors. 3 have security issues..."

You:     "@SILVIA what's the security level?"
SILVIA:  "Current user security level: 5 (Administrator)"

You:     "@LLM create a secure greeting"
LLM:     "learn behavior greeting,secure,hello {...} [executes CLI command]"
SILVIA:  "Behavior created: greeting.secure.hello (ID: 1248)"

This is UNPRECEDENTED - you're literally having a three-way conversation where:

  • SILVIA (deterministic) provides facts, executes commands
  • LLM provides analysis, generates solutions
  • Human provides direction, oversight

The CLI Architecture ​

Nine Command Categories ​

1. System Commands ​

help                    → Show all commands
help [topic]           → Context-aware help
status                 → Brain state & stats
info                   → Detailed metadata
compiler log           → Last compilation errors
recompile              → Rebuild brain scripts
undo [count]           → Undo operations (128 depth!)
redo [count]           → Redo operations

2. Brain Management ​

load [file]            → Load brain file
new [file]             → Create fresh brain
save [file]            → Save brain file
merge [file]           → Merge brain file
export [file]          → Export brain
reload                 → Reload current brain

3. Live Training (Requires live on) ​

learn behavior [spec]  → Create/modify behavior
learn absorber [spec]  → Add input pattern
learn exuder [spec]    → Add output pattern
learn concept [spec]   → Add concept binding

4. Inspection Commands ​

behaviors [range]      → List behaviors
concepts [range]       → List concepts
context                → Show context stack
get variable $name     → Get variable value
get variables          → All variables
get config             → Configuration
get behavior [id]      → Behavior details
get absorber [id]      → Absorber details
get exuder [id]        → Exuder details
get scripts            → Global scripts

5. Modification Commands ​

set variable $name val → Set variable
set config [params]    → Set configuration
set absorber [params]  → Modify absorber
set exuder [params]    → Modify exuder
set behavior [params]  → Modify behavior
set headers [code]     → Set using statements
set global [code]      → Set global code

6. Removal Commands ​

remove concept [name]          → Delete concept
remove concept bindings [name] → Remove bindings
remove behavior [id]           → Delete behavior
remove absorber [id]           → Delete absorber
remove exuder [id]             → Delete exuder

7. Feedback & WordNet Learning ​

feedback on|off|status         → Spontaneous generation control
feedback interval [min] [max]  → Timer range (seconds, default: 20-30)
feedback chance [0.0-1.0]      → Utterance probability (default: 1.0)
feedback threshold [wt] [cnt]  → Concept weight + min count (default: 0.25, 1)
feedback stacksize [n]         → Max memory entries (default: 1000)
feedback clear                 → Wipe feedback memory
wordnet on|off|status          → WordNet auto-binding (Tier 1)
wordnet learn on|off|status    → Definitions → feedback (Tier 2)
wordnet deep on|off|status     → Relations → feedback (Tier 3)
wordnet "[word]"               → Dictionary lookup

8. Seed & Ingest ​

seed on|off|status             → Auto-create behaviors from feedback
ingest "[sentence]"            → Seed one knowledge sentence
ingest file "[path]"           → Batch seed from text file

9. Unity Scene Control ​

unity inspect [path]           → Serialize GameObject to YAML
unity modify [path] [params]   → Modify GameObject properties
unity find [criteria]          → Search for GameObjects
unity component [operations]   → Manage components
unity gameobject [operations]  → Manage GameObjects

LIVE CLI Features ​

Undo/Redo System (128 Depth) ​

Every command that modifies the brain is tracked:

csharp
You:     "remove behavior greeting,hello"
SILVIA:  "Behavior removed."

You:     "Oh wait, I need that!"
You:     "undo"
SILVIA:  "Undone: remove behavior greeting,hello"

You:     "undo 5"
SILVIA:  "Undone 5 operations"

You:     "redo 3"
SILVIA:  "Redone 3 operations"

Tracks:

  • Behavior creation/modification/deletion
  • Absorber/exuder changes
  • Variable modifications
  • Configuration changes
  • Script updates

128 levels deep - you can experiment fearlessly!

Live Learning Mode ​

Enable runtime brain authoring with live on:

csharp
You:     "live on"
SILVIA:  "LIVE mode enabled - brain authoring unlocked"

You:     "learn behavior support,technical,help {notes:Tech support}"
SILVIA:  "Behavior created: support.technical.help (ID: 1249)"

You:     "learn absorber 1249 {text:I need help with *}"
SILVIA:  "Absorber created: 'I need help with *' (ID: 0)"

You:     "learn exuder 1249 {text:I can help with that. What's the issue?}{reuse}"
SILVIA:  "Exuder created with reuse flag (ID: 0)"

You:     "test: I need help with login"
SILVIA:  "I can help with that. What's the issue?"

You:     "Perfect! save"
SILVIA:  "Brain saved to support_brain.slv"

This is conversational AI authoring - no IDE, no compilation, just chat!

Scene Manipulation from Chat (Unity) ​

Control Unity scenes through chat commands:

csharp
You:     "unity inspect Camera/Main"
SILVIA:  [Returns YAML hierarchy of Main Camera]

You:     "@LLM analyze the camera setup"
LLM:     "The camera FOV is 60, positioned at (0,1,-10)..."

You:     "unity modify Camera/Main transform.position 0,5,-15"
SILVIA:  "Camera position updated to (0,5,-15)"

You:     "unity find tag:Enemy"
SILVIA:  "Found 12 GameObjects with tag 'Enemy'"

You:     "unity component add BoxCollider Enemy_01"
SILVIA:  "BoxCollider added to Enemy_01"

You:     "@LLM create a patrol AI for the enemies"
LLM:     "unity component add PatrolAI Enemy* [executes command]"
SILVIA:  "PatrolAI component added to 12 GameObjects"

You just gave LLM direct control over Unity scenes through conversational commands!

No other system does this:

  • Chat-based scene manipulation
  • Multi-agent scene control
  • LLM can execute Unity commands
  • Real-time scene updates
  • All through natural language

Contextual Help System ​

Smart help based on what you're trying to do:

csharp
You:     "help learn"
SILVIA:  [Shows only LEARN commands with detailed syntax]

You:     "help unity"
SILVIA:  [Shows only Unity commands with examples]

You:     "help variables"
SILVIA:  [Shows variable commands + syntax + examples]

Portable WordNet Integration ​

Dictionary lookup and tiered semantic learning in chat:

csharp
You:     "wordnet \"ambiguous\""
SILVIA:  "ambiguous (adj): open to multiple interpretations
          Synonyms: equivocal, unclear
          Example: The message was ambiguous"

You:     "wordnet on"
SILVIA:  "WordNet enabled."

You:     "wordnet status"
SILVIA:  "WordNet: on | Learn: off | Deep: off"

You:     "@LLM find synonyms for 'fast'"
LLM:     "wordnet \"fast\" [executes]"
SILVIA:  "fast (adj): quick, rapid, swift, speedy..."

Tiered Learning Mode (pre-training with semantic knowledge):

csharp
You:     "wordnet on"
SILVIA:  "WordNet enabled."

You:     "wordnet learn on"
SILVIA:  "WordNet Learn (definitions → feedback) enabled."

You:     "wordnet deep on"
SILVIA:  "WordNet Deep (relations → feedback) enabled."

You:     "seed on"
SILVIA:  "Seed mode enabled."

You:     "feedback on"
SILVIA:  "Feedback enabled"

// Now talk normally - SILVIA learns definitions and relations,
// creates reusable behaviors, then spontaneously generates from them
You:     "Tell me about music"
// [Auto-binds "music" relations, seeds behaviors, feedback generates]
[18 seconds later]
SILVIA:  "so, music is a type of art"

Batch Knowledge Import (from any source):

csharp
// Import a domain knowledge file
You:     "ingest file \"domain_glossary.txt\""
SILVIA:  "Ingested 142 of 150 lines from domain_glossary.txt"

You:     "feedback on"
// SILVIA now has 142 reusable knowledge behaviors to draw from

Search API Integration ​

Search external APIs from chat:

csharp
You:     "searchapi \"weather in tokyo\" 10"
SILVIA:  [Returns top 10 search results about Tokyo weather]

You:     "@LLM summarize the weather"
LLM:     "Based on search results: Tokyo is sunny, 22°C..."

Complete Command Reference ​

System Commands ​

help ​

Show all available CLI commands.

Usage:

$> help

Output:

SILVIA LIVE CLI Commands:

SYSTEM COMMANDS:
 help - Show this help
 status - Brain status
 info - Detailed info
 ...

help [topic] ​

Context-aware help for specific command area.

Usage:

$> help learn
$> help unity
$> help variables

Output: Filtered help for specific topic

status ​

Show current brain state and operational status.

Usage:

$> status

Output:

SILVIA Core: Active
Brain File: customer_support.slv
Behaviors: 1,247
Concepts: 8,532
Live Mode: ON
User Security Level: 5
Modified: Yes

info ​

Show detailed brain metadata and configuration.

Usage:

$> info

Output:

Brain Information:
  File: customer_support.slv (v3.1)
  Created: 2025-10-01 14:32:15
  Modified: 2025-10-13 09:45:22
  Size: 2.4 MB
  
Configuration:
  Absorber Fitness: 0.5
  Reusable Threshold: 0.3
  Dynamic Depth: 3
  Context Depth: 5
  Wildcard Floor: 0.1
  Wildcard Ceiling: 0.9
  
Statistics:
  Total Behaviors: 1,247
  Total Concepts: 8,532
  Total Bindings: 12,445
  Active Groups: 12

compiler log ​

Display last compilation errors from script recompilation.

Usage:

$> compiler log

Output:

Last Compilation: FAILED
Errors: 2

Error 1 (Line 42): CS0103 - The name 'undefined_var' does not exist
Error 2 (Line 58): CS1002 - ; expected

recompile ​

Recompile brain scripts (security restricted in DEPLOY mode).

Usage:

$> recompile

Output:

Recompiling brain scripts...
Compilation: SUCCESS
Compiled 47 behaviors with scripts

undo [count] ​

Undo one or more previous operations (max depth: 128).

Usage:

$> undo
$> undo 5

Output:

Undone: learn behavior greeting,hello
[or]
Undone 5 operations

redo [count] ​

Redo previously undone operations.

Usage:

$> redo
$> redo 3

Brain Management Commands ​

load [file] ​

Load a brain from file (.sil, .slx, or .txt format).

Usage:

$> load customer_support.slv
$> load brains/medical_expert.sil

Output:

Loading: customer_support.slv
Loaded: 1,247 behaviors, 8,532 concepts
Boot behavior executed
Brain loaded successfully

new [file] ​

Create a fresh, empty brain.

Usage:

$> new
$> new fresh_brain.slv

Output:

Created new brain: fresh_brain.slv
Ready for authoring

save [file] ​

Save current brain to file (auto-adds .sil extension).

Usage:

$> save
$> save updated_brain

Output:

Saving to: updated_brain.sil
Saved: 1,248 behaviors, 8,547 concepts
Brain saved successfully

merge [file] ​

Merge another brain file into current brain.

Usage:

$> merge medical_domain.slv

Output:

Merging: medical_domain.slv
Added: 347 behaviors, 1,892 concepts
Merge complete

export [file] ​

Export current brain to specified file path.

Usage:

$> export exports/brain_backup.slv

reload ​

Reload currently loaded brain file (reverts unsaved changes).

Usage:

$> reload

Output:

Reloading: customer_support.slv
WARNING: Unsaved changes will be lost
Reloaded successfully

Live Training Commands ​

All LIVE commands require live on first.

live on / live off / live status ​

Enable/disable LIVE mode for runtime brain authoring.

Usage:

$> live on
$> live status
$> live off

Output:

LIVE mode: ENABLED
Brain authoring unlocked - use 'learn' commands

learn behavior [spec] ​

Create or modify a behavior.

Syntax:

learn behavior [group],[subgroup],[name] {parameters}
learn behavior [group],[name] {parameters}

Parameters:

  • {notes:...} - Behavior notes
  • {data:...} - Behavior data
  • {securitylevel:N} - Security level
  • {a:text} - Add absorber shorthand
  • {e:text} - Add exuder shorthand

Usage:

$> learn behavior support,technical,help {notes:Technical support behavior}
$> learn behavior greeting,hello {a:hello}{a:hi there}{e:Hello!}{e:Hi!}

Output:

Behavior created: support.technical.help (ID: 1249)

learn absorber [behaviorID] {spec} ​

Add an absorber to a behavior.

Syntax:

learn absorber [behaviorID] {parameters}

Parameters:

  • {text:...} - Absorber text (required)
  • {exact} - Exact match flag
  • {reject} - Rejection filter flag
  • {prompt} - LLM prompt flag
  • {data:...} - Absorber data
  • {required:0,1,0} - Required concepts

Usage:

$> learn absorber 1249 {text:I need help with *}{data:tech_support}
$> learn absorber 1249 {text:spam}{reject}
$> learn absorber greeting,hello {text:hello *}

Output:

Absorber created: 'I need help with *' (ID: 0)

learn exuder [behaviorID] {spec} ​

Add an exuder to a behavior.

Syntax:

learn exuder [behaviorID] {parameters}

Parameters:

  • {text:...} - Exuder text (required)
  • {exact} - Exact output flag
  • {dynamic} - Dynamic generation flag
  • {reuse} - Reuse for Markov flag
  • {prompt} - LLM prompt flag
  • {data:...} - Exuder data
  • {val:code} - Validation script
  • {pre:code} - Pre-execution script
  • {post:code} - Post-execution script

Usage:

$> learn exuder 1249 {text:I can help with that}{reuse}{dynamic}
$> learn exuder 1249 {text:Response: $result}{post:LogResponse()}

Output:

Exuder created with reuse+dynamic flags (ID: 0)

learn concept [spec] ​

Learn concept bindings.

Syntax:

learn concept [name] | [boundTo],[bindingType] || [name2] | [boundTo2],[bindingType2]

Usage:

$> learn concept tokyo | japan,location
$> learn concept programming | coding,synonym | skill,isa

Output:

Concept binding created: tokyo → japan (location)
Concept binding created: programming → coding (synonym)
Concept binding created: programming → skill (isa)

Inspection Commands ​

behaviors [range] ​

List behaviors (supports range parameters).

Usage:

$> behaviors
$> behaviors 0-10
$> behaviors 100-110

Output:

Behaviors [0-10]:
0: system.boot
1: conversation.greeting.hello
2: conversation.greeting.goodbye
3: support.technical.help
...

concepts [range] ​

List concepts (supports range parameters).

Usage:

$> concepts
$> concepts 0-100

Output:

Concepts [0-100]:
0: hello
1: goodbye
2: help
3: support
...

context ​

Get or manipulate current context stack.

Usage:

$> context

Output:

Context Stack [depth: 3]:
[0] Behavior: greeting.hello (weight: 0.95)
[1] Behavior: conversation.main (weight: 0.87)
[2] Behavior: system.boot (weight: 0.62)

get variables / get variables system / get variables user / get variables sensor ​

Get all variables or specific variable types.

Usage:

$> get variables
$> get variables system
$> get variables user
$> get variables sensor

Output:

System Variables:
  $_a = "SILVIA"
  $_u = "John"
  $_i = "Hello there"
  $_o = "Hello! How can I help?"
  
User Variables:
  $user_name = "John Doe"
  $session_id = "abc123"
  
Sensor Variables:
  $@temperature = "22.5"
  $@humidity = "65"

get variable $name ​

Get value of a specific variable.

Usage:

$> get variable $_a
$> get variable $user_name

Output:

$_a = "SILVIA"

get config ​

Get current brain configuration settings.

Usage:

$> get config

Output:

Configuration:
  Absorber Fitness: 0.5
  Reusable Threshold: 0.3
  Wildcard Floor: 0.1
  Wildcard Ceiling: 0.9
  Wildcard Multiplier: 1.0
  Dynamic Depth: 3
  Context Depth: 5

get behavior [identifier] ​

Get detailed information about a specific behavior.

Syntax:

get behavior [behaviorID]
get behavior [group],[name]
get behavior [group],[subgroup],[name]

Usage:

$> get behavior 42
$> get behavior greeting,hello
$> get behavior support,technical,help

Output:

Behavior: support.technical.help (ID: 1249)
  Group: support
  Subgroup: technical
  Name: help
  Security Level: 3
  Created: 2025-10-13 09:30:15
  Modified: 2025-10-13 09:45:22
  
Absorbers: 3
  [0] I need help with *
  [1] help me with *
  [2] technical support
  
Exuders: 2
  [0] I can help with that. What's the issue?
  [1] Let me assist you with that.
  
Scripts:
  Pre: ValidateUserLevel()
  Post: LogSupportRequest()

get behavior absorbers [identifier] ​

Get all absorbers for a behavior.

Usage:

$> get behavior absorbers greeting,hello

get behavior exuders [identifier] ​

Get all exuders for a behavior.

Usage:

$> get behavior exuders greeting,hello

get behavior scripts [identifier] ​

Get all scripts for a behavior.

Usage:

$> get behavior scripts greeting,hello

get concept [name] ​

Get detailed information about a concept.

Usage:

$> get concept tokyo

Output:

Concept: tokyo (ID: 425)
  Weight: 0.75
  Stopword: false
  In Use: true
  
Bindings:
  → japan (location)
  → city (isa)
  → megacity (property)
  → asia (location)

get absorber [behaviorID]/[absorberID] ​

Get information about a specific absorber.

Usage:

$> get absorber 1249/0
$> get absorber greeting,hello/0

Output:

Absorber [1249/0]:
  Text: "I need help with *"
  Exact: false
  Reject: false
  Prompt: false
  Required: null
  Data: "tech_support"

get exuder [behaviorID]/[exuderID] ​

Get information about a specific exuder.

Usage:

$> get exuder 1249/0

Output:

Exuder [1249/0]:
  Text: "I can help with that. What's the issue?"
  Exact: false
  Dynamic: true
  Reuse: true
  Prompt: false
  Security Level: 3
  Context: null
  PAGER Tags: null

get scripts ​

Get global brain scripts.

Usage:

$> get scripts

Output:

Global Scripts:

HEADERS (using statements):
using System;
using System.Collections.Generic;
using Newtonsoft.Json;

GLOBAL (namespace/class code):
public static class Helpers {
    public static string FormatResponse(string text) {
        return text.Trim().ToUpper();
    }
}

Modification Commands ​

set variable $name value ​

Set or modify variable values.

Usage:

$> set variable $_a SILVIA
$> set variable $user_name "John Doe" $session_id abc123

Output:

$_a = "SILVIA"
$user_name = "John Doe"
$session_id = "abc123"

set config [parameters] ​

Set brain configuration parameters.

Usage:

$> set config absorber_fitness 0.7
$> set config dynamic_depth 5 context_depth 8

Output:

Configuration updated:
  Absorber Fitness: 0.5 → 0.7
  Dynamic Depth: 3 → 5
  Context Depth: 5 → 8

set absorber [behavior]/[absorberID] {params} ​

Modify absorber properties.

Usage:

$> set absorber 1249/0 {text:I need assistance with *}{exact}
$> set absorber greeting,hello/0 {data:greeting_v2}

Output:

Absorber [1249/0] updated:
  Text: "I need help with *" → "I need assistance with *"
  Exact: false → true

set exuder [behavior]/[exuderID] {params} ​

Modify exuder properties.

Usage:

$> set exuder 1249/0 {text:How can I help you?}{dynamic}{reuse}

set behavior [identifier] {params} ​

Modify behavior properties.

Usage:

$> set behavior 1249 {notes:Updated technical support}{securitylevel:5}
$> set behavior greeting,hello {data:greeting_data_v3}

set headers [code] ​

Set top-level using statements for script compilation.

Usage:

$> set headers using System; using System.Linq; using Newtonsoft.Json;

Output:

Headers updated:
using System;
using System.Linq;
using Newtonsoft.Json;

set global [code] ​

Set global internal code within brain's namespace and class.

Usage:

$> set global public static class Utils { public static int Add(int a, int b) { return a + b; } }

reset config ​

Reset brain configuration to reasonable defaults.

Usage:

$> reset config

Output:

Configuration reset to defaults:
  Absorber Fitness: 0.5
  Reusable Threshold: 0.3
  Wildcard Floor: 0.1
  Wildcard Ceiling: 0.9
  Wildcard Multiplier: 1.0
  Dynamic Depth: 3
  Context Depth: 5

Removal Commands ​

remove concept [name] ​

Remove a concept from the brain.

Usage:

$> remove concept obsolete_term

Output:

Concept 'obsolete_term' removed

remove concept bindings [name] ​

Remove all bindings from a concept.

Usage:

$> remove concept bindings tokyo

Output:

Removed 4 bindings from concept 'tokyo'

remove behavior [identifier] ​

Remove a behavior from the brain.

Usage:

$> remove behavior 1249
$> remove behavior greeting,hello
$> remove behavior support,technical,help

Output:

Behavior removed: support.technical.help (ID: 1249)

remove absorber [behaviorID]/[absorberID] ​

Remove an absorber from a behavior.

Usage:

$> remove absorber 1249/0
$> remove absorber greeting,hello/2

remove exuder [behaviorID]/[exuderID] ​

Remove an exuder from a behavior.

Usage:

$> remove exuder 1249/1

Control Commands ​

optimize ​

Optimize brain processing and performance settings.

Usage:

$> optimize

Output:

Brain optimization:
  Concept weights recalculated
  Behavior groups reorganized
  Context depth optimized
  Performance improved by 23%

randomize ​

Randomize brain behavior selection patterns.

Usage:

$> randomize

Output:

Behavior selection randomized
Exuder selection randomized

debug on / debug off / debug toggle ​

Enable/disable/toggle debug mode.

Usage:

$> debug on
$> debug off
$> debug toggle

Output:

Debug mode: ENABLED
Verbose logging: ON
Performance metrics: ON

jump to [behavior] [probability] ​

Execute a jump to a specific behavior.

Usage:

$> jump to greeting,hello 1.0
$> jump to support,help 0.8

Output:

Jump set: greeting.hello (probability: 1.0)

Search & WordNet Commands ​

searchapi "[query]" [length] ​

Execute a search using the search API.

Usage:

$> searchapi "weather in tokyo" 10
$> searchapi "machine learning tutorials" 5

Output:

Search Results (10):
1. Tokyo Weather Forecast - 22°C, Sunny
2. Current Weather in Tokyo, Japan
3. Tokyo Climate Information
...

wordnet "[word]" ​

Lookup a word in WordNet dictionary.

Usage:

$> wordnet "ambiguous"

Output:

ambiguous (adjective):
  Definition: Open to multiple interpretations
  Synonyms: equivocal, unclear, vague
  Example: "The message was ambiguous"
  
ambiguous (adjective):
  Definition: Having more than one possible meaning
  Synonyms: cryptic, enigmatic

wordnet on / wordnet off / wordnet status ​

Enable/disable/check WordNet auto-binding (Tier 1). When enabled, every new word encountered during conversation automatically creates semantic bindings (synonym, antonym, parent, child, partOf, related) from WordNet.

Usage:

$> wordnet on
$> wordnet status
$> wordnet off

Status Output (shows all tiers):

WordNet: on | Learn: off | Deep: off

wordnet learn on / wordnet learn off / wordnet learn status ​

Enable/disable WordNet definition injection into feedback (Tier 2). When enabled, WordNet glosses (definitions) for each new word are injected into the feedback stack via SuggestFeedback. This makes definitional material available to the Markov chain generator for spontaneous output.

Requires wordnet on to have effect. For visible output, also enable feedback on.

Usage:

$> wordnet on
$> wordnet learn on
$> feedback on

What happens: When you say "ambiguous", its WordNet gloss ("open to two or more interpretations; or of uncertain nature or significance") is queued and injected into the feedback stack. The feedback timer can then generate spontaneous utterances incorporating this definitional knowledge.

Output:

WordNet Learn (definitions → feedback) enabled.

wordnet deep on / wordnet deep off / wordnet deep status ​

Enable/disable WordNet relation sentence injection into feedback (Tier 3). When enabled, natural language relation sentences are generated from WordNet data and injected into the feedback stack alongside definitions.

Requires wordnet on to have effect. For visible output, also enable feedback on.

Usage:

$> wordnet on
$> wordnet deep on
$> feedback on

What happens: When you say "car", the following sentences are generated and injected into feedback:

  • "car is similar to auto and automobile" (synonyms)
  • "car is a type of vehicle" (hypernym)
  • "sedan is a type of car" (hyponym)
  • "wheel is part of car" (meronym)
  • "car is related to automotive" (derivational)

These well-formed English sentences become Markov chain material, enabling SILVIA to spontaneously generate responses that reflect semantic knowledge.

Output:

WordNet Deep (relations → feedback) enabled.

Tier Summary:

TierCommandInjectsPurpose
1wordnet onBindings onlyEnriches matching (absorber, memory)
2wordnet learn onDefinitions → feedbackGives Markov generator definitional material
3wordnet deep onRelation sentences → feedbackGives Markov generator relational sentences

Example Pre-Training Session:

$> wordnet on
$> wordnet learn on
$> wordnet deep on
$> feedback on
You: "Tell me about architecture"
[SILVIA auto-binds "architecture" relations, injects definitions + relation sentences]
[20 seconds later]
SILVIA: "so, architecture is a type of design"
You: "What about buildings?"
[SILVIA auto-binds "buildings", injects definitions]
[15 seconds later]
SILVIA: "anyway, a building is a type of structure"

Feedback Commands ​

feedback on / feedback off / feedback status ​

Enable/disable/check the spontaneous feedback generation system. When active, SILVIA periodically generates novel utterances from conversational memory using reusable exuders.

Usage:

$> feedback on
$> feedback status
$> feedback off

Status Output (shows all tuning values):

Feedback: on | Interval: 20.0-30.0s | Chance: 100% | Threshold: 0.25 (min 1) | Stack: 47/1000

What Happens When Active:

  1. Timer fires at random interval within configured range (default 20-30 seconds)
  2. Samples concepts from feedback stack (conversational memory)
  3. Runs concepts through brain inference, filtered to reusable exuders only
  4. If matched exuder is dynamic, Markov chains construct novel response
  5. Applies threshold (concept weight) + probability (chance) + anti-repetition filters
  6. If all pass, SILVIA speaks unprompted (sometimes prefixed with "so " or "anyway, ")

feedback interval [min] [max] ​

Set the timer range in seconds between spontaneous utterances. Each cycle, a random value between min and max is chosen.

Usage:

$> feedback interval 20 30
$> feedback interval 5 10
$> feedback interval

Running with no arguments shows the current values.

Defaults: 20-30 seconds.

Tuning Tips:

  • For demos/standups: feedback interval 5 10 (faster responses)
  • For natural conversation: feedback interval 20 30 (default)
  • For background ambient: feedback interval 60 120 (occasional)

feedback chance [0.0-1.0] ​

Set the probability of SILVIA actually uttering a thought when the timer fires and conditions are met.

Usage:

$> feedback chance 1.0
$> feedback chance 0.5
$> feedback chance

Running with no arguments shows the current value.

Default: 1.0 (100% -- always speak when conditions met).

How it works: When the timer fires and a valid response passes the threshold check, a random number is compared against this value. If random <= chance, SILVIA speaks. Otherwise, the thought is skipped.

feedback threshold [weight] [count] ​

Set the minimum conceptual weight and concept count required for SILVIA to consider a thought worth uttering.

Usage:

$> feedback threshold 0.25 1
$> feedback threshold 0.1 1
$> feedback threshold

Running with no arguments shows the current values.

Defaults: 0.25 weight, 1 concept.

Parameters:

  • weight (0.0-1.0): Each concept has a weight (frequency/importance). Only concepts at or above this weight count toward the minimum.
  • count (>= 1): At least this many concepts in the generated response must exceed the weight threshold.

Tuning Tips:

  • Lower weight (0.1) = more permissive, SILVIA speaks about almost anything
  • Higher weight (0.5+) = more selective, only high-importance concepts trigger speech
  • Higher count (2-3) = requires richer conceptual content to speak

feedback stacksize [n] ​

Set the maximum number of feedback entries kept in memory. When exceeded, oldest entries are removed (FIFO).

Usage:

$> feedback stacksize 1000
$> feedback stacksize 5000
$> feedback stacksize

Running with no arguments shows current count and max.

Default: 1000.

Tuning: Larger stacks retain more conversational history, allowing SILVIA to blend older concepts with newer ones. Smaller stacks focus on recent conversation.

feedback clear ​

Wipe the entire feedback stack and utterance history. Settings (interval, chance, threshold) are preserved.

Usage:

$> feedback clear

Output:

Feedback stack and utterance history cleared.

Use this to reset SILVIA's conversational memory without changing tuning. Useful between demo sessions or when pivoting topics.

Feedback Tuning Summary:

ParameterCommandDefaultEffect
Intervalfeedback interval 20 3020-30sHow often SILVIA tries to speak
Chancefeedback chance 1.0100%Probability of speaking when ready
Thresholdfeedback threshold 0.25 10.25, 1Quality gate for utterances
Stack Sizefeedback stacksize 10001000Conversational memory depth

Demo Preset (fast, responsive):

$> feedback interval 5 10
$> feedback chance 1.0
$> feedback threshold 0.1 1

Relationship to WordNet Learning: When combined with wordnet learn on and/or wordnet deep on, the feedback stack accumulates WordNet definitions and relation sentences. When combined with seed on, these also become reusable behaviors. The spontaneous generation then draws from both the feedback stack and the seeded behaviors to produce knowledge-informed responses.

See Also: ApiFeedback for programmatic control via C# API.

Seed & Ingest Commands ​

seed on / seed off / seed status ​

Enable/disable/check seed mode. When active, anything that flows through SuggestFeedback (including WordNet definitions and relations) is automatically turned into a behavior with reusable exuders.

Usage:

$> seed on
$> seed status
$> seed off

Status Output:

Seed mode: on | Knowledge entries: 47

What Happens When Active:

  1. Text enters SuggestFeedback (from WordNet learn/deep, or manual suggestion)
  2. Content words are extracted (stop words stripped) and added as an absorber
  3. Full sentence is added as a reusable exuder
  4. Both are placed in a "seed.knowledge" behavior group
  5. Behaviors auto-bucket at 100 exuders each (seed.knowledge, seed.knowledge_001, etc.)

Why This Matters: Without seed mode, the feedback system has material to think about (the feedback stack) but no reusable exuders to say. Seed mode closes that gap -- every injected piece of knowledge becomes something SILVIA can actually output.

ingest "[sentence]" ​

Manually seed a single sentence as a knowledge behavior. Also adds it to the feedback stack.

Usage:

$> ingest "a dog is a type of animal"
$> ingest "the capital of France is Paris"
$> ingest "photosynthesis converts light into energy"

Output:

Seeded: a dog is a type of animal

ingest file "[path]" ​

Batch seed sentences from a text file, one per line. Lines starting with # are treated as comments and skipped. Also adds each sentence to the feedback stack.

Usage:

$> ingest file "C:\knowledge\animals.txt"
$> ingest file "domain_glossary.txt"

Output:

Ingested 142 of 150 lines from animals.txt

File Format:

# Animal taxonomy
a dog is a type of mammal
a cat is a type of mammal
a mammal is a type of animal
a bird is a type of animal
# Relationships
a wing is part of a bird
fur is part of a mammal

Quick Standup Recipe:

$> wordnet on
$> wordnet learn on
$> wordnet deep on
$> seed on
$> feedback on
You: "Tell me about architecture"
[WordNet auto-binds, definitions + relations become behaviors, feedback generates]
SILVIA: "so, architecture is a type of design"

Cleanup: To remove all seeded knowledge: remove behavior seed,*

Unity Scene Commands ​

unity inspect [path] ​

Serialize Unity GameObject hierarchy to YAML format.

Syntax:

unity inspect [GameObject path or name]

Usage:

$> unity inspect Camera/Main
$> unity inspect Player
$> unity inspect Enemies/Enemy_01

Output:

yaml
GameObject: Main
  Path: Camera/Main
  Active: true
  Tag: MainCamera
  Layer: 0
  
Components:
  - Camera:
      fieldOfView: 60
      nearClipPlane: 0.3
      farClipPlane: 1000
      clearFlags: Skybox
  
  - Transform:
      position: (0, 1, -10)
      rotation: (0, 0, 0)
      scale: (1, 1, 1)
  
Children:
  - Canvas
  - EventSystem

unity modify [path] [property] [value] ​

Modify Unity GameObject properties and values.

Syntax:

unity modify [path] [property] [value]

Usage:

$> unity modify Camera/Main transform.position 0,5,-15
$> unity modify Player transform.rotation 0,90,0
$> unity modify Enemy_01 active false
$> unity modify Light/Directional light.intensity 1.5

Output:

Modified: Camera/Main
  transform.position: (0,1,-10) → (0,5,-15)

unity find [criteria] ​

Search for Unity GameObjects by criteria.

Syntax:

unity find tag:[tagName]
unity find name:[objectName]
unity find layer:[layerName]
unity find component:[componentType]

Usage:

$> unity find tag:Enemy
$> unity find name:Player*
$> unity find component:BoxCollider
$> unity find layer:UI

Output:

Found 12 GameObjects:
  - Enemies/Enemy_01 (tag: Enemy)
  - Enemies/Enemy_02 (tag: Enemy)
  - Enemies/Enemy_03 (tag: Enemy)
  ...

unity component add/remove/modify [params] ​

Manage Unity GameObject components.

Syntax:

unity component add [ComponentType] [GameObject]
unity component remove [ComponentType] [GameObject]
unity component modify [GameObject] [Component] [property] [value]

Usage:

$> unity component add BoxCollider Enemy_01
$> unity component add Rigidbody Player
$> unity component remove BoxCollider Enemy_01
$> unity component modify Player Rigidbody mass 2.0

Output:

Component added: BoxCollider → Enemy_01
  isTrigger: false
  center: (0,0,0)
  size: (1,1,1)

unity gameobject create/destroy/clone [params] ​

Manage Unity GameObject instantiation and lifecycle.

Syntax:

unity gameobject create [name] [parent] [position]
unity gameobject destroy [path]
unity gameobject clone [source] [name]

Usage:

$> unity gameobject create NewEnemy Enemies 10,0,5
$> unity gameobject clone Enemy_01 Enemy_13
$> unity gameobject destroy Enemies/Enemy_13

Output:

GameObject created: NewEnemy
  Parent: Enemies
  Position: (10, 0, 5)

Multi-Agent Workflow Examples ​

Example 1: Three-Way Debugging Session ​

You:     "status"
SILVIA:  "Core active, 1,247 behaviors, live mode: ON"

You:     "test: hello"
SILVIA:  [No response]

You:     "@SILVIA why no response?"
SILVIA:  "No behavior matched input 'hello'"

You:     "@LLM find greeting behaviors"
LLM:     "behaviors [executes command]"
SILVIA:  "Behaviors [0-10]: ..."

LLM:     "I see behavior 'conversation.greeting.hello' exists"

You:     "@LLM check the absorbers"
LLM:     "get behavior absorbers conversation,greeting,hello [executes]"
SILVIA:  "No absorbers found for behavior 'conversation.greeting.hello'"

You:     "@LLM fix it"
LLM:     "learn absorber conversation,greeting,hello {text:hello}{text:hi} [executes]"
SILVIA:  "Absorbers created (IDs: 0, 1)"

You:     "test: hello"
SILVIA:  "Hello there!"

You:     "Perfect! @SILVIA save"
SILVIA:  "Brain saved to conversation.slv"

Three agents collaborated to:

  1. Human identified the problem
  2. SILVIA provided diagnostic data
  3. LLM analyzed and generated fix
  4. Human validated and saved

Example 2: Unity Scene Setup via Chat ​

You:     "@LLM create a patrol system for enemies"

LLM:     "unity find tag:Enemy [executes]"
SILVIA:  "Found 12 Enemy GameObjects"

LLM:     "unity component add NavMeshAgent Enemy* [executes]"
SILVIA:  "NavMeshAgent added to 12 GameObjects"

LLM:     "unity component add PatrolAI Enemy* [executes]"
SILVIA:  "PatrolAI component added to 12 GameObjects"

LLM:     "unity modify Enemy* PatrolAI patrolRadius 10 [executes]"
SILVIA:  "Updated PatrolAI.patrolRadius → 10 for 12 GameObjects"

You:     "@SILVIA inspect Enemy_01"
SILVIA:  [Returns YAML with NavMeshAgent + PatrolAI configured]

You:     "Perfect! @LLM create waypoints for patrol"

LLM:     "unity gameobject create Waypoint_01 Patrol 0,0,0 [executes]"
         "unity gameobject create Waypoint_02 Patrol 10,0,0 [executes]"
         "unity gameobject create Waypoint_03 Patrol 10,0,10 [executes]"
         "unity gameobject create Waypoint_04 Patrol 0,0,10 [executes]"
SILVIA:  "4 waypoints created in Patrol group"

You:     "Test it in play mode"

Result: Complete patrol system created through conversational commands!

Example 3: Collaborative Brain Authoring ​

You:     "@LLM analyze the customer support behaviors"

LLM:     "get behavior count [executes]"
SILVIA:  "Total behaviors: 1,247"

LLM:     "behaviors 0-100 [executes]"
SILVIA:  [Lists first 100 behaviors]

LLM:     "Analysis: I found 47 support behaviors.
          Issues:
          - 12 have no security levels set
          - 8 are missing reject filters for spam
          - 23 need dynamic exuders for variety"

You:     "@LLM fix the security issues"

LLM:     [Executes series of set behavior commands]
         "set behavior support,billing,* {securitylevel:5}"
         "set behavior support,technical,* {securitylevel:3}"
         "set behavior support,general,* {securitylevel:0}"
SILVIA:  "12 behaviors updated with security levels"

You:     "@LLM add spam filters"

LLM:     [Executes learn commands for each support behavior]
         "learn absorber support,* {text:spam}{reject}"
         "learn absorber support,* {text:advertisement}{reject}"
SILVIA:  "16 spam filters added"

You:     "@LLM add response variety"

LLM:     [Modifies exuders to enable dynamic generation]
         "set exuder support,*/0 {dynamic}{reuse}"
SILVIA:  "23 exuders updated with dynamic generation"

You:     "@SILVIA test with spam input"
You:     "test: spam advertisement"
SILVIA:  [No response - rejected by filters]

You:     "@SILVIA test with valid input"
You:     "test: I need help with billing"
SILVIA:  "I can assist you with billing. What's your question?"

You:     "Excellent! save"
SILVIA:  "Brain saved to support_updated.slv"

Collaboration outcome:

  • LLM analyzed 1,247 behaviors
  • Found 3 categories of issues
  • Generated and executed 50+ fix commands
  • Human validated results
  • SILVIA confirmed changes

Example 4: Real-Time Learning from Conversation ​

You:     "live on"
SILVIA:  "LIVE mode enabled"

You:     "test: what's the refund policy?"
SILVIA:  "I don't have information about that."

You:     "@LLM learn a refund policy behavior"

LLM:     "learn behavior support,policy,refund {notes:Refund policy info} [executes]"
SILVIA:  "Behavior created (ID: 1250)"

LLM:     "learn absorber 1250 {text:refund policy}{text:refund *}{text:return policy} [executes]"
SILVIA:  "3 absorbers created"

You:     "@LLM the policy is: 30-day money back guarantee, no questions asked"

LLM:     "learn exuder 1250 {text:Our refund policy: 30-day money-back guarantee, no questions asked.}{reuse} [executes]"
         "learn exuder 1250 {text:We offer a 30-day refund policy with no questions asked.}{reuse} [executes]"
SILVIA:  "2 exuders created with reuse flag"

You:     "test: what's the refund policy?"
SILVIA:  "Our refund policy: 30-day money-back guarantee, no questions asked."

You:     "test: tell me about refunds"
SILVIA:  "We offer a 30-day refund policy with no questions asked."

You:     "Perfect! save"
SILVIA:  "Brain saved - learned: support.policy.refund"

Learning flow:

  1. Gap identified in real conversation
  2. LLM creates behavior structure
  3. Human provides policy content
  4. LLM converts to exuders
  5. Immediate testing
  6. Live deployment

Novel Workflows Afforded ​

1. ChatOps for AI Development ​

Traditional: Write code → Compile → Deploy → Test → Debug → Repeat

SILVIA LIVE: Chat → Test → Fix → Deploy (all in conversation)

2. Multi-Agent Collaboration ​

No other system has:

  • Deterministic AI that answers questions
  • LLM that generates solutions
  • Human that provides oversight
  • All three working together in chat

3. Unity Scene Control from Chat ​

Unprecedented capability:

@LLM create 100 enemies with patrol AI
[LLM executes 100+ Unity commands]
[Scene is populated in seconds]

You just gave AI direct control over game development!

4. Zero-Code Brain Authoring ​

No IDE required:

"live on"
"learn behavior ..."
"test: ..."
"Looks good!"
"save"

Anyone can author AI brains through conversation.

5. 128-Level Undo ​

Experiment fearlessly:

  • Try radical changes
  • Break things
  • Undo 50 operations
  • Back to working state
  • Keep experimenting

6. Addressing Protocol ​

Route commands to:

  • @SILVIA for deterministic responses
  • @LLM for intelligent analysis
  • @Human for decisions
  • Broadcast for all

This is multi-agent orchestration through natural language.

Best Practices ​

1. Use Addressing for Clarity ​

GOOD:
"@LLM analyze greeting behaviors"
"@SILVIA show me behavior 42"
"@LLM fix the security issues"

BAD:
"analyze this" (who should respond?)

2. Enable Live Mode for Authoring ​

GOOD:
"live on"
"learn behavior ..."
"test: ..."
"save"
"live off"

BAD:
"learn behavior ..." (without live mode - fails)

3. Leverage Undo for Experimentation ​

GOOD:
"remove behavior greeting,*"
[Test without greetings]
"Hmm, need those back"
"undo"
[Back to working state]

BAD:
Save before every risky change (slow!)

4. Collaborate with LLM ​

GOOD:
"@LLM find all behaviors with security issues"
[LLM analyzes]
"@LLM fix them"
[LLM executes fixes]
"@SILVIA verify"
[SILVIA confirms]

BAD:
Manually inspect 1,247 behaviors yourself

5. Use Unity Commands for Rapid Prototyping ​

GOOD:
"@LLM setup enemy patrol system"
[LLM creates components, waypoints, config]
"Test in play mode"

BAD:
Manually add components to 100 enemies

See Also ​

  • ApiData - Commands execute ApiData methods for brain authoring
  • ApiBrain - Test commands use ApiBrain for inference, WordNet toggle
  • ApiMem - Load/save/merge commands use ApiMem
  • ApiFeedback - Feedback commands control spontaneous generation
  • All APIs - CLI provides conversational access to entire SILVIA API

SILVIA LIVE CLI - The multi-agent conversational AI authoring revolution. Build brains and control applications through natural language collaboration between Deterministic AI, LLM AI, and Human intelligence.

© Copyright Cognitive Code Corp. 2007-2026

SILVIA is a registered Trademark of Cognitive Code Corp.

SILVIA is a registered Trademark of Cognitive Code Corp.

© Copyright Cognitive Code Corp. 2007-2026