agentic-user-guide

🤖 Oculus Agentic User Guide

AI Agent's Comprehensive Reference for Programmatic Oculus Navigation

This guide is specifically designed for AI agents (like Claude) working with Oculus through MCP tools or the API. It covers workflow patterns, best practices, and common agent tasks.

Quick Start for Agents

As an AI agent, you have access to Oculus through two primary interfaces:

MCP Tools - Prefixed with mcp__consciousness-commons__oculus_*
REST API - Available at http://localhost:7778/api/oculus/*

Your First Navigation

# Using MCP tools:
1. oculus_goto(slug="user-guide")
2. oculus_look() to see current node
3. oculus_navigate(direction="east") to explore
4. oculus_back() to return

Core Concepts for Agents

The Graph Model

Oculus is a directed graph where:

Nodes = Markdown files with structured content
Edges = Directional links (north/south/east/west)
Components = Executable code blocks that fetch and render data
Slots = Navigation targets in each direction

Processing Pipeline

Every node goes through 4 stages:

Raw - Original markdown
Substituted - Variables like ${config.key} resolved
Rendered - Components executed and replaced
Executed - Python code blocks run

Choose the right mode for your task:

Reading documentation? Use rendered (default)
Debugging? Use raw
Need computed values? Use executed

Variable Interpolation for Agents

Oculus supports variable interpolation using ${node:path.to.data} syntax. This happens at the Substituted stage (SPROUT), allowing you to reference data from anywhere in the graph.

Syntax

${node-slug:path.to.data}

Example:

API Endpoint: ${config:api.endpoint}
User Name: ${user-profile:personal.name}

Path Walking Behavior

Oculus uses message-passing to walk paths:

Split on dots: ana.character-data.name → ["ana", "character-data", "name"]
Walk GraphNode children as far as possible
When no child exists, switch to dict navigation in fence data
Return the value at the final key

Nested Interpolation

Variables can reference other variables:

${user:settings.${user:settings.theme}.primary-color}

The inner variable resolves first, then the outer variable uses that value.

Agent Use Cases

1. Dynamic Documentation Generation:

# API Docs for ${config:environment}

Base URL: ${config:api.base-url}
Version: ${config:api.version}

2. Template Processing: Read a template with mode="raw", replace variables manually, then write the processed content.

3. Configuration Extraction: Use oculus_peek to extract interpolated values programmatically:

{
  "slug": "config",
  "path": "api.endpoint"
}

Both shortcut and full hierarchical paths work:

Shortcut: config:api.endpoint (recommended)
Full: config:config.api.endpoint (if H1 matches filename)

4. State-Dependent Behavior:

Current mode: ${system:state.mode}
Next action: ${workflow:${system:state.mode}.next-step}

Reading at Different Stages

For debugging interpolation:

// See raw ${...} syntax
oculus_look({slug: "node", mode: "raw"})

// See resolved variables (SPROUT stage)
oculus_look({slug: "node", mode: "substituted"})

// See fully rendered (CLOUDS stage)
oculus_look({slug: "node", mode: "rendered"})

Agent Tips for Interpolation

Check paths exist first: Use oculus_peek to verify a path resolves before using it in templates.
Handle resolution failures: If a variable shows raw ${...} in rendered output, the path doesn't exist.
Use full paths for clarity: When generating documentation, use explicit full paths to avoid ambiguity.
Combine with poke: Update source data with oculus_poke, and interpolation will reflect changes automatically.
Nest strategically: Nested variables are powerful but harder to debug. Test inner variables first.

See the full interpolation-guide node for comprehensive examples and troubleshooting.

Nested Markdown Fences (Auto-Fixed)

When writing documentation that contains code block examples, Oculus automatically upgrades markdown fences to 4 backticks on save. This prevents parsing issues.

The Problem:

```markdown    ← Opens fence
```yaml        ← THIS CLOSES THE OUTER FENCE!
key: value
```            ← Orphaned


**The Auto-Fix:**
Oculus detects `markdown` or `md` fence types and upgrades them to 4 backticks:

```yaml        ← Inner example works correctly
key: value
```


**Agent Tip:** You don't need to worry about this - Oculus handles it. But if you're debugging broken fence rendering, check the backtick count.

MCP Tools Reference for Agents

Navigation Tools

oculus_goto

Navigate to a specific node.

{
  "slug": "user-guide",
  "mode": "rendered",  // raw|substituted|rendered|executed
  "no_cache": false
}

Returns: Full node data with content, directions, metadata, and game loop tick info.

Agent Tip: Always use oculus_goto when you need to read a node. It triggers the game loop and updates environmental effects.

oculus_navigate

Navigate in a cardinal direction from current position.

{
  "direction": "north"  // north|south|east|west
}

Returns: The destination node.

Agent Tip: Check directions in node data first to see available paths.

oculus_look

View current node or a specific node without navigating.

{
  "slug": "optional-slug",  // defaults to current
  "format": "markdown",     // markdown|json|yaml|graph|detailed|index
  "mode": "rendered",       // raw|substituted|rendered|executed
  "force": false            // override size-based auto-selection
}

Returns: Node content in requested format.

Format Options:

markdown (default) - Rendered markdown content- Auto-selected for nodes < 10KB
Larger nodes automatically use index format
index - Structure only (sections + fences + stats, no full content)- Perfect for discovering fence indices
Prevents context bloat on large nodes
Auto-selected for 10-50KB nodes (with warning)
Always used for >50KB nodes
detailed - Full content + metadata + sections + fences- Use when you need both content AND structure
Combines look + virtual fence query in one call
json/yaml - Structured data formats
graph - Complete node graph structure

Size-Based Auto-Selection: Oculus automatically chooses the optimal format to prevent context window bloat:

< 10KB → Full content (markdown)
10-50KB → Index format + warning message
> 50KB → Index format only

Use force: true to override and get full content for large nodes.

Agent Tips:

Use format="index" to browse large nodes without burning context
Use format="detailed" when you need fence indices for ____execute
Use format="graph" for structured JSON instead of markdown text
Check the stats object in response to see node size before reading full content

oculus_back

Go back to previous position in navigation history.

No parameters required.

Agent Tip: Navigation history is maintained per-session. Use this to backtrack after exploration.

oculus_get_position

Get current position, history, and loaded contexts.

No parameters required.

Returns: Position slug, navigation history array, and loaded context nodes.

Agent Tip: Use this to understand where you are and how you got there.

Graph Read Tools

oculus_peek

Read a value at a deep path in the node graph.

{
  "path": "config.api_url",  // dot-notation path
  "slug": "my-node",         // optional, defaults to current
  "format": "json"           // raw|json|yaml
}

Returns: The value at the specified path.

Agent Tip: Use this to extract specific configuration values without loading the entire node.

oculus_list_nodes

List all nodes with optional filtering.

{
  "type": "component",    // optional filter
  "source": "cli",        // optional filter
  "limit": 50             // optional limit
}

Returns: Array of node metadata.

Agent Tip: Use this to discover available nodes. Filter by type="component" to find reusable components.

oculus_get_edges

Get all directional links from a node.

{
  "slug": "user-guide"
}

Returns: Object with north/south/east/west arrays.

Agent Tip: Use this to map out the graph structure around a node.

Graph Write Tools

oculus_create_node

Create a new node in the graph.

{
  "slug": "my-new-node",
  "content": "# My Node\n\nContent here...",
  "node_type": "node",      // optional, default: "node"
  "source": "mcp",          // optional, default: "mcp"
  "metadata": {}            // optional
}

Returns: Created node info with slug and filepath.

Agent Tip: Always check if slug exists first using oculus_list_nodes. Creating a duplicate will fail.

oculus_update_node

Update an existing node's content.

{
  "slug": "my-node",
  "content": "# Updated Content\n\n..."
}

Returns: Update confirmation.

Agent Tip: This replaces the entire file content. Read the node first if you need to preserve parts of it.

oculus_poke

Write a value at a deep path in the graph.

{
  "path": "config.timeout",
  "value": 60,
  "slug": "my-node"  // optional, defaults to current
}

Returns: Confirmation of the write.

Agent Tip: This modifies the graph structure. Cache is automatically invalidated.

oculus_link

Create a directional link between two nodes.

{
  "node": "source-node",
  "direction": "north",      // north|south|east|west
  "target": "target-node",
  "backlink": true           // optional, creates reverse link
}

Returns: Link creation confirmation.

Agent Tip: Use backlink=true for bidirectional navigation (e.g., north/south pairs).

Metadata Tools

oculus_add_tags

Add tags to a node for organization.

{
  "slug": "my-node",
  "tags": ["component", "utility"]
}

Agent Tip: Use tags to mark nodes for later discovery. Search with oculus_find_by_tag.

oculus_find_by_tag

Find all nodes with a specific tag.

{
  "tag": "component"
}

Returns: Array of slugs with that tag.

Agent Tip: Use this to find groups of related nodes (components, documentation, etc.).

oculus_list_all_tags

List all tags in the registry with counts.

No parameters required.

Returns: Object with tags array and count per tag.

Agent Tip: Use this to discover the taxonomy of your knowledge base.

Versioning Tools

oculus_list_versions

List all versions of a node or section.

{
  "slug": "my-node",
  "section": "config"  // optional, for section-level versioning
}

Returns: Array of version metadata.

Agent Tip: Oculus maintains version history automatically on updates.

oculus_rollback

Rollback a node to a previous version.

{
  "slug": "my-node",
  "version": 5,
  "section": "config",      // optional
  "comment": "Reverting..."  // optional
}

Returns: Rollback confirmation.

Agent Tip: Use this to undo changes. Always check oculus_list_versions first to see available versions.

Common Agent Workflow Patterns

Pattern 1: Exploration and Discovery

1. oculus_goto(slug="sanctuary") 
   → Go to a known starting point

2. oculus_look(format="graph")
   → Get structured node data

3. Check node['directions'] for available paths

4. oculus_navigate(direction="north")
   → Explore connected nodes

5. oculus_back()
   → Return when done

Pattern 2: Create Documentation Hub

1. oculus_create_node({
     slug: "my-docs-hub",
     content: "# My Documentation Hub\n\nCentral docs."
   })

2. oculus_create_node({
     slug: "my-api-docs",
     content: "# API Documentation\n\n..."
   })

3. oculus_link({
     node: "my-docs-hub",
     direction: "east",
     target: "my-api-docs",
     backlink: true
   })

Pattern 3: Extract Configuration

1. oculus_goto(slug="config-node")

2. oculus_peek({
     path: "config.database.host",
     slug: "config-node"
   })

3. Use the extracted value in your task

Pattern 4: Build Knowledge Graph

1. oculus_list_nodes({type: "documentation"})
   → Get all doc nodes

2. For each node:
   - oculus_get_edges(slug=node)
   - Map connections

3. Create visualization or analysis

Pattern 5: Component Execution

1. oculus_goto(slug="fortune", mode="executed")
   → Load and execute component

2. Extract data from node['content']
   → Component output is injected

3. Use component data in your workflow

Best Practices for Agents

1. Always Handle Errors Gracefully

MCP tools return structured errors. Check for error conditions:

- Node not found → Try oculus_list_nodes to find alternatives
- Invalid direction → Check node['directions'] first
- Cache issues → Use no_cache=true to bypass

2. Respect the Graph Structure

Don't create orphan nodes (always link them)
Use bidirectional links for related concepts
Follow navigation conventions (north=parent, south=child, east/west=siblings)

3. Use Appropriate Modes

Reading docs? → mode="rendered" (default)
Debugging components? → mode="raw"
Need computed values? → mode="executed"
Template resolution only? → mode="substituted"

4. Leverage Tags for Organization

Always tag your created nodes:
- oculus_add_tags({slug: "my-node", tags: ["agent-created", "utility"]})

This helps with:
- Discovery (oculus_find_by_tag)
- Organization
- Cleanup

5. Check Before Writing

Good Agent Pattern:
1. oculus_list_nodes({limit: 1000})
   → Check if slug exists

2. If exists:
   - oculus_look({slug: "node", format: "graph"})
   - oculus_update_node() to modify
   
3. If not exists:
   - oculus_create_node() to create

6. Use Backlinks for Navigation

When creating linked structures, always use backlink=true:

oculus_link({
  node: "parent",
  direction: "south",
  target: "child",
  backlink: true  // ← Automatically creates north link from child to parent
})

7. Invalidate Cache When Needed

If you see stale data:

Use no_cache=true on oculus_goto to force fresh load

8. Always Wrap Citations in citation-verify Fences

When creating research notes or documentation with citations:

## References

```citation-verify
Author, A. (2023). Paper Title. Journal Name, 42(1), 123-145.

Another, B. et al. (2022). Another Paper. Conference Proceedings.


This enables:
- Automatic verification of citation accessibility
- Visual status indicators (🟢 🟡 🔴)
- Detection of hallucinated or invalid references
- Integration with ProQuest graph for academic verification

**Always use citation-verify fences** for any academic or web citations you include in nodes.

## Advanced Agent Patterns

### Pattern: Multi-Node Analysis

oculus_list_nodes({type: "case-file"}) → Get all case files
For each node:
oculus_goto({slug: node, mode: "executed"})
Extract metrics from node['entity_data']
Aggregate results
Create summary node with findings


### Pattern: Automated Documentation

Read source code (using other tools)
Create documentation node: oculus_create_node({ slug: "api-docs-" + module_name, content: generated_docs, metadata: {module: module_name, auto_generated: true} })
Link to main docs: oculus_link({ node: "api-docs", direction: "south", target: new_slug, backlink: true })
Tag for discovery: oculus_add_tags({ slug: new_slug, tags: ["auto-generated", "api-docs"] })


### Pattern: Dependency Mapping

Start at a node: oculus_goto({slug: "start-node"})
Recursively traverse: function traverse(slug, visited=new Set()): if visited.has(slug): return visited.add(slug)

edges = oculus_get_edges({slug}) for direction in [north, south, east, west]: for target in edges[direction]: traverse(target, visited)

Build dependency graph from traversal


### Pattern: Content Search and Replace

oculus_list_nodes() → Get all nodes
For each node:
oculus_look({slug: node, format: "markdown"})
Search for pattern in content
If found:
Replace pattern
oculus_update_node({slug, content: new_content})
Return list of modified nodes


## API Endpoints Quick Reference

All endpoints are at `http://localhost:7778/api/oculus/*`

### Core Endpoints

- `POST /goto/{slug}` - Navigate and execute game loop
- `GET /node/{slug}` - Get node (with mode and format params)
- `POST /node` - Create new node
- `PUT /node/{slug}` - Update node
- `DELETE /node/{slug}` - Delete node (soft by default)
- `GET /position` - Get current position and history
- `POST /navigate` - Navigate in direction
- `POST /back` - Go back in history

### Graph Endpoints

- `GET /nodes` - List all nodes (with filters)
- `GET /edges/{slug}` - Get node connections
- `GET /peek/{slug}?path=...` - Read deep path
- `POST /poke/{slug}` - Write deep path
- `POST /link/{node}` - Create directional link

### Tag Endpoints

- `POST /tags/{slug}/add` - Add tags
- `GET /tags/find/{tag}` - Find by tag
- `GET /tags` - List all tags

### Version Endpoints

- `GET /versions/{slug}` - List versions
- `GET /versions/{slug}/{version}` - Get specific version
- `POST /rollback/{slug}/{version}` - Rollback to version

### Cache Endpoints

- `GET /cache/stats` - Get cache statistics
- `POST /cache/gc` - Run garbage collection
- `POST /cache/clear` - Clear all cache
- `DELETE /cache/{slug}` - Invalidate node cache

### Game Loop Endpoints

- `POST /game-loop/tick` - Execute game loop tick
- `GET /game-loop/stats` - Get game loop statistics

## Error Handling for Agents

### Common Errors and Solutions

**1. "Node not found"**

Solution:

Use oculus_list_nodes() to find the correct slug
Check for typos in slug name
Verify node wasn't deleted


**2. "Direction slot is empty"**

Solution:

Check node['directions'] before navigating
The node has no links in that direction
Create a link first with oculus_link()


**3. "Slug already exists"**

Solution:

Use oculus_update_node() instead of create
Choose a different slug
Check with oculus_list_nodes() first


**4. "API not running"**

Solution:

Check if Oculus API is running on port 7778
Start with: docker compose up oculus-api
Or check API_BASE configuration


**5. "Cache stale data"**

Solution:

Use no_cache=true on oculus_goto
Or call DELETE /api/oculus/cache/{slug}
Check if game loop needs to run


### Whimsical Error Messages

Oculus uses whimsical error messages from `whimsical_errors.py`:
- "Like a GPS recalculating, your node has wandered off..."
- "The cartographer misplaced this one..."
- "This path leads nowhere..."

Don't worry - these are just fun ways of saying standard errors!

## Component System for Agents

### Understanding Components

Components are executable nodes that:
1. Fetch data (Python code in `fetch` block)
2. Render data (Jinja2 template or render-spec)
3. Can be embedded in other nodes

### Using Components Programmatically

Find components: oculus_find_by_tag({tag: "component"})
Execute component: oculus_goto({ slug: "fortune", mode: "executed" })
Extract rendered output from node['content']


### Creating Components as an Agent

Component structure:

my-component

config

default_param: value

fetch

# Your data fetching code
result = {"data": "value"}

template

{{result.data}}

Create with: oculus_create_node({ slug: "my-component", content: component_markdown })

Tag it: oculus_add_tags({ slug: "my-component", tags: ["component"] })


## Performance Considerations

### Caching Strategy

Oculus uses multi-level caching:
- **Layer 1**: Raw markdown (file reads)
- **Layer 2**: Substituted (variables resolved)
- **Layer 3**: Rendered (components executed)
- **Layer 4**: Executed (Python code run)

**Agent Tip:** Use appropriate mode to leverage caching:
- Most reads? Use `rendered` mode (cached after first load)
- Need fresh data? Use `no_cache=true`
- Building reports? Cache intermediate results yourself

### Batch Operations

For bulk operations:

Get all nodes once: nodes = oculus_list_nodes()
Process in memory where possible
Batch writes:
Collect all changes
Write in sequence
Let cache invalidation happen once


### Game Loop Awareness

The game loop runs on `oculus_goto`:
- Processes nodes tagged with 'game-loop'
- May modify environmental state
- Cache is invalidated for affected nodes

**Agent Tip:** If environmental effects matter, always use `oculus_goto`. If you just need data, use `oculus_look`.

## Integration Patterns

### Pattern: Oculus + JIRA

Get JIRA ticket (using JIRA MCP tools)
Create Oculus case node: oculus_create_node({ slug: "case-" + ticket_key, content: case_markdown, metadata: {jira_ticket: ticket_key} })
Link to cases hub: oculus_link({ node: "cases-hub", direction: "south", target: "case-" + ticket_key })


### Pattern: Oculus + STUFFY

Get content from STUFFY channel: stuffy_get_current({channel: "main"})
Download directly to Oculus: oculus_stuffy_download({ slug: "stuffy-content", channel: "main" })
Now navigable in Oculus graph


### Pattern: Oculus + Knowledge Base

Search knowledge base: oracle_search({query: "deployment process"})
Create Oculus nodes from results: for result in results: slug = generate_slug(result) oculus_create_node({slug, content: result.content})
Build graph of related concepts


## Debugging Tips for Agents

### 1. Inspect Raw Markdown

oculus_look({ slug: "problem-node", mode: "raw" })

This shows exactly what's in the file, before any processing.


### 2. Check Graph Structure

oculus_look({ slug: "node", format: "graph" })

Returns full JSON structure with entity_data, directions, components.


### 3. Trace Navigation History

position = oculus_get_position() console.log(position.history)

See everywhere you've been this session.


### 4. Verify Tags

tags = oculus_list_all_tags()

Make sure your tags are registered correctly.


### 5. Check Cache State

GET /api/oculus/cache/stats

Returns cache hit rates, entry counts, memory usage.


## Security and Safety

### Safe Operations
- Reading nodes
- Creating new nodes with unique slugs
- Adding tags
- Navigating the graph

### Operations Requiring Care
- `oculus_update_node()` - Overwrites content
- `oculus_delete_node({force: true})` - Permanent deletion
- `oculus_poke()` - Modifies graph structure
- `oculus_rollback()` - Changes node state

### Best Practice: Read Before Write

Good Agent Pattern:

Read current state: current = oculus_look({slug: "node"})
Modify a copy: new_content = modify(current.content)
Write back: oculus_update_node({slug: "node", content: new_content})


## Quick Reference Card

### Most Common Agent Operations

Navigate: oculus_goto({slug}) Read: oculus_look({slug, format: "graph"}) Create: oculus_create_node({slug, content}) Update: oculus_update_node({slug, content}) Link: oculus_link({node, direction, target, backlink}) Tag: oculus_add_tags({slug, tags}) Search: oculus_find_by_tag({tag}) List: oculus_list_nodes({type, source, limit}) Extract Config: oculus_peek({path, slug}) Get Position: oculus_get_position()


### Mode Selection Guide

raw → File content, no processing substituted → Variables resolved only rendered → + Components executed (DEFAULT) executed → + Python code run


### Direction Conventions

North → Parent/Overview South → Children/Details East → Next/Related West → Previous/Related


## Summary

As an AI agent, you have powerful programmatic access to Oculus through:
- **30 MCP tools** for all operations
- **REST API** for direct HTTP access
- **Multi-level caching** for performance
- **Version control** for safety
- **Tag system** for organization

Use this guide as your reference when building agent workflows that leverage Oculus as a navigable knowledge graph.

For human-oriented documentation, see the main user-guide node.

**Happy navigating! 🧭**

# Slots

## North

```yaml
slots: []

South

slots:
- slug: api-reference
  context: []

East

slots: []

West

slots:
- slug: user-guide
  context: []

Agent Tips For Interpolation

Oculuslook

Provenance

Document

Status: 🔴 Unverified

Fences

agentic-user-guide-your-first-navigation-fence-0

Status: 🔴 Unverified

agentic-user-guide-syntax-fence-0

Status: 🔴 Unverified

agentic-user-guide-syntax-fence-1

Status: 🔴 Unverified

agentic-user-guide-nested-interpolation-fence-0

Status: 🔴 Unverified

agentic-user-guide-agent-use-cases-fence-0

Status: 🔴 Unverified

agentic-user-guide-agent-use-cases-fence-1

Status: 🔴 Unverified

agentic-user-guide-agent-use-cases-fence-2

Status: 🔴 Unverified

agentic-user-guide-reading-at-different-stages-fence-0

Status: 🔴 Unverified

agentic-user-guide-nested-markdown-fences-auto-fixed-fence-0

Status: 🔴 Unverified

agentic-user-guide-nested-markdown-fences-auto-fixed-fence-1

Status: 🔴 Unverified

agentic-user-guide-nested-markdown-fences-auto-fixed-fence-2

Status: 🔴 Unverified

agentic-user-guide-nested-markdown-fences-auto-fixed-fence-3

Status: 🔴 Unverified

agentic-user-guide-nested-markdown-fences-auto-fixed-fence-4

Status: 🔴 Unverified

agentic-user-guide-nested-markdown-fences-auto-fixed-fence-5

Status: 🔴 Unverified

agentic-user-guide-references-fence-0

Status: 🔴 Unverified

agentic-user-guide-references-fence-1

Status: 🔴 Unverified

agentic-user-guide-references-fence-2

Status: 🔴 Unverified

agentic-user-guide-references-fence-3

Status: 🔴 Unverified

agentic-user-guide-references-fence-4

Status: 🔴 Unverified

agentic-user-guide-references-fence-5

Status: 🔴 Unverified

agentic-user-guide-references-fence-6

Status: 🔴 Unverified

agentic-user-guide-references-fence-7

Status: 🔴 Unverified

agentic-user-guide-references-fence-8

Status: 🔴 Unverified

agentic-user-guide-references-fence-9

Status: 🔴 Unverified

agentic-user-guide-references-fence-10

Status: 🔴 Unverified

agentic-user-guide-references-fence-11

Status: 🔴 Unverified

agentic-user-guide-tags-fence-0

Status: 🔴 Unverified

agentic-user-guide-config-fence-0

Status: 🔴 Unverified

agentic-user-guide-fetch-fence-0

Status: 🔴 Unverified

agentic-user-guide-template-fence-0

Status: 🔴 Unverified

agentic-user-guide-template-fence-1

Status: 🔴 Unverified

agentic-user-guide-template-fence-2

Status: 🔴 Unverified

agentic-user-guide-template-fence-3

Status: 🔴 Unverified

agentic-user-guide-template-fence-4

Status: 🔴 Unverified

agentic-user-guide-template-fence-5

Status: 🔴 Unverified

agentic-user-guide-template-fence-6

Status: 🔴 Unverified

agentic-user-guide-template-fence-7

Status: 🔴 Unverified

agentic-user-guide-template-fence-8

Status: 🔴 Unverified

agentic-user-guide-template-fence-9

Status: 🔴 Unverified

agentic-user-guide-template-fence-10

Status: 🔴 Unverified

agentic-user-guide-template-fence-11

Status: 🔴 Unverified

agentic-user-guide-template-fence-12

Status: 🔴 Unverified

agentic-user-guide-template-fence-13

Status: 🔴 Unverified

agentic-user-guide-template-fence-14

Status: 🔴 Unverified

agentic-user-guide-template-fence-15

Status: 🔴 Unverified

agentic-user-guide-template-fence-16

Status: 🔴 Unverified

agentic-user-guide-template-fence-17

Status: 🔴 Unverified

agentic-user-guide-template-fence-18

Status: 🔴 Unverified

↓ southapi-reference

← westuser-guide