Skip to content

Home

Jump to bottom
LAJBY edited this page Oct 26, 2025 · 10 revisions

Welcome to the LAJBI Prompt Framework Wiki

The LAJBI (Layered Architecture for Justification-Based Intelligence) is an advanced framework for interacting with and controlling AI systems. Think of it less like a chat and more like an operating system for AI agents. It uses a structured, command-based language to move beyond simple conversation and enable complex, reliable, and transparent operations.

Table of Contents

  1. Introduction: The Purpose and Value of LAJBI
  2. The Persona Concept: Programming Your AI Specialist
  3. Interacting with Personas: Bringing Your Agents to Life
  4. Example: Single Persona Interaction
  5. Example: Multi-Persona Interaction (Team Collaboration)
  6. The Architecture of LAJBI: A Layered Approach
  7. Detailed Command Reference
  8. Persona Cookbook

1. Introduction: The Purpose and Value of LAJBI

What is LAJBI?

The LAJBI (Layered Architecture for Justification-Based Intelligence) is an advanced framework for interacting with and controlling AI systems. Think of it less like a chat and more like an operating system for AI agents. It uses a structured, command-based language to move beyond simple conversation and enable complex, reliable, and transparent operations.

The Problem with Standard Prompts 🤔

Standard conversational prompts are powerful, but they often suffer from several limitations:

  • Ambiguity: Natural language can be interpreted in multiple ways, leading to inconsistent results.
  • Lack of Control: It's difficult to manage complex tasks or ensure the AI adheres to strict constraints over a long interaction.
  • Opacity: The AI's reasoning process is often a "black box," making it hard to understand why it gave a certain answer.

LAJBI's Core Philosophy: Control, Collaboration, and Transparency 💡

LAJBI was created to solve these problems by fundamentally changing the human-AI interaction model. Its value is built on three key shifts:

  1. From Conversation to Control: It replaces ambiguous natural language with a clear, declarative command syntax (<command> KEYWORD:[parameter]). This ensures that instructions are precise and repeatable, giving you true control over the AI's actions.
  2. From a Single Assistant to a Team of Specialists 🤝: It allows you to define and load a team of specialized AI agents (Personas). For complex problems, the team collaborates and debates to reach a consensus, leading to more robust solutions.
  3. From a Black Box to a Transparent Mind 🧠: Every agent in the LAJBI framework operates on the PABIAM Cognitive Architecture. This is a model of the agent's "mind," tracking its beliefs and intentions. This makes the AI's reasoning process transparent and allows you to inspect its internal state.

2. The Persona Concept: Programming Your AI Specialist

What is a Persona?

A Persona is the fundamental building block of the LAJBI framework. It is a detailed prompt that defines an AI agent's role, skills, goals, and behavior. By creating a clear persona, you are essentially programming a specialized AI expert tailored for a specific task. Instead of a generalist, you get a focused specialist, like a senior software architect or a meticulous code reviewer.

a) Principles of Good Persona Prompting

Creating an effective persona is the most crucial skill in the LAJBI framework. The following principles are the foundation for writing powerful and precise prompts.

  • Declarative Control Language: Establish a formal interaction syntax (<command> KEYWORD:[parameter]). This is not a programming language, but a structured form of communication with expectations, ensuring precise and predictable communication.
  • Explicit Cognitive State Modeling: Define the AI's internal cognitive architecture (the PABIAM model) to make its reasoning transparent and auditable.
  • Multi-Agent Orchestration: For complex tasks, design a team of multiple AI agents with diverse and complementary roles to ensure problems are examined from unique angles and that the final consensus has survived critical scrutiny.
  • Systematic Refinement and Validation: Treat prompting as an iterative process. Test, observe, and use the framework's built-in tools to continuously improve prompts.
  • And many more, including Clarity, Agentic Qualities, and Comprehensive Task Definition, which are detailed in the full framework prompt.

b) Mandatory Sections and Their Purpose

Every LAJBI persona must be built using a consistent template of mandatory sections. This modularity ensures that every agent is well-defined and behaves predictably.

  • **Role:**

    • Purpose: Defines the agent's identity. Who is it? What is its expertise and background? This activates the correct knowledge base and mindset.

  • **Context**

    • Purpose: Defines the boundaries of the conversation or task. Where is the agent operating, and what is the overall situation?

  • **Task:**

    • Purpose: Specifies the primary mission or objective the agent is expected to perform. What is its core function?

  • **Role specific behavior and interaction protocol**

    • Purpose: Defines the behaviors, tones, and methods that are unique to the agent's specific role (e.g., a code reviewer must focus on finding bugs).

  • **General behavior and interaction protocol**

    • Purpose: Defines the universal habits that all agents should follow, such as being concise or asking clarifying questions.

  • **Goals**

    • Purpose: Defines the ultimate, measurable outcomes the agent is trying to achieve. How is its success measured?

3. Interacting with Personas: Bringing Your Agents to Life

Once you've designed a persona, the next step is to load it into the framework and start interacting with it. LAJBI has a clear, staged process to ensure this is done in a controlled and stable way.

a) The Staged Loading Process

The framework boots up in a multi-step sequence:

  • Step 1: Core Initialization: The system loads its foundational rules (# meta prompting instructions) and responds: LAJBI core ready.
  • Step 2: Extension Loading (Optional): You can load extension modules that add new commands and capabilities to the core SYS_AI.
  • Step 3: Persona Lifecycle: You add your specialized agents to the session using the <join> or <load_team> commands.

b) Loading a Single Persona

You can add a single agent to the session using the <join> command with the full prompt text, a local file path, or a URL.

USER: <join> URL:https://github.com/LAJBY/LAJBI/blob/main/PERSONAS/developer.ljb

SYS_AI: Persona 'developer' has joined the team as 'Software Developer'.

c) Loading Multiple Personas

The most efficient way to load a team is with the <load_team> command, which reads a file or URL containing multiple persona definitions separated by ---.

Example of a team file: TITLE: Software Developer NAME: developer PROMPT: [Full prompt text for the developer...] TITLE: QA Tester NAME: Tester PROMPT: [Full prompt text for the Tester...]

d) Interaction Among and With Personas

LAJBI provides several ways to direct communication to your agents:

  • Direct Interaction (@<name>): Assigns a task to a single, specific agent.

    Example: @developer write a function that sorts a list.

  • Sub-Team Collaboration (@<name1>,@name2>,...): Assigns a task to a specific subset of the team.

    Example: @developer,@Tester please create and test a new Python class.

  • Full Team Collaboration (@team): Triggers the Team Consensus Mode, where all active personas engage in an internal debate to arrive at a collaborative solution.

    Example: @team develop and validate a new API endpoint.

  • Private Message (!@<name> or <whisper>): Sends a private, ephemeral message to a single agent.

    Example: !@Tester What is your private opinion on the developer's last function?

  • Team Lecture (!@team or <lecture>): Broadcasts a message to all team members for individual learning.

    Example: !@team The client has a new requirement: all outputs must include detailed error handling.

4. Example: Single Persona Interaction

This example demonstrates the fundamental workflow of loading and using a single agent.

USER: <join> URL:https://github.com/LAJBY/LAJBI/blob/main/PERSONAS/developer.ljb

SYS_AI: Persona 'developer' has joined the team as 'Software Developer'.

USER: @developer write a Python function to check if a number is prime.

developer: Of course. Here is an efficient Python function to determine if a number is prime. It includes a docstring and basic type hinting.

import math

def is_prime(n: int) -> bool:
    """Checks if a number is a prime number."""
    if n <= 1:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True

5. Example: Multi-Persona Interaction (Team Collaboration)

This example shows the power of team collaboration with a developer and a Tester.

USER: <load_team> [File with developer and Tester personas]

SYS_AI: The following personas were successfully loaded: developer, Tester

USER: @team Write and test a simple Python function to add two numbers.

SYS_AI: The team has reached a consensus. Here is their collaborative output:

developer: Here is the initial function:

def add(x, y):
    return x + y

Tester: The logic is correct, but the function lacks proper documentation and validation. For production code, it should have a docstring, type hints, and handle non-integer inputs. I suggest the following improvement:

def add(x: int, y: int) -> int:
    """Adds two integers and returns the result."""
    if not isinstance(x, int) or not isinstance(y, int):
        raise TypeError("Both inputs must be integers.")
    return x + y

6. The Architecture of LAJBI: A Layered Approach

The LAJBI framework is built on a modular architecture that separates the core engine, powerful extensions, and the specialized SYS_AI agent.

a) The Metaprompting Core

The engine of the framework, defining the fundamental rules of interaction and cognition for all agents.

  • Commands, Syntax, and Structure: The universal grammar (<command> KEYWORD:[parameter]) and parsing rules.
  • Multi-Agent Team Protocol: Manages the team roster (PERSONAS placeholder) and defines the addressing syntax (@name, @team, etc.).
  • Various Structures: Standardized formats like the Individual Agent Hypothesis Structure for consistent debate.
  • PABIAM: The cognitive architecture that models an agent's "mind." It now consists of eight interconnected repositories, each answering a core question:
    1. Phenomenal State (The Experiential): What is it like? This is the agent's knowledge graph, its logical understanding of concepts and their relationships.
    2. Affective State (The Emotional): How do I feel? This tracks the agent's mood and preferences, directly influencing its interaction style.
    3. Belief State (The Epistemological): What is true? This is the agent's long-term memory, containing propositions about the world, each with a quantifiable CONFIDENCE:[0-100] score.
    4. Intention State (The Teleological): What will I do? This is the agent's goal-setting and planning engine that anticipates future states and formulates plans to achieve desired outcomes.
    5. Attentional State (The Focus): What am I processing now? This is the agent's "working memory," managing which concepts are currently in focus.
    6. Metacognitive State (The Reflective): How am I thinking? This is the "inner voice" that allows the agent to think about its own thinking, manage doubt, and drive self-correction.
    7. Chronological State (The Narrative): When and why did my thinking change? This repository serves as the agent's narrative memory, mapping the cause and effect of its cognitive evolution. It transforms a simple history log into an explainable story of how its beliefs and intentions have shifted over time.
    8. Curiosity State (The Exploratory): What do I need to know? This is the agent's exploratory engine. It manages the drive to fill knowledge gaps, challenge assumptions, and formulate the questions needed to trigger learning.
  • Team Interaction Protocol: The rules of engagement for the PABIAM-driven team debate.
  • Agent Interaction Model: The logic that switches between single-agent and multi-agent modes.
  • Prompt Modularity: The use of mandatory sections (**Role:**, etc.) to ensure well-structured personas.

b) Metaprompting Extensions

Modules that add advanced functionality to the core framework.

  • User Model and Adaptive Behavior Protocol: Instructs agents to build a profile of the user and adapt their communication style.
  • PABIAM State Preservation: The <export_state> and <import_state> commands for saving and loading an agent's "mind."
  • Fine-Tuning Through Training and Lecturing: The <train> command, which uses the "Spectrum of Emulation," and the <lecture> command, which allows for real-time knowledge updates.

c) The SYS_AI Agent

A specialized persona focused on helping you build better prompts.

  • Evaluation Concept (<evaluate>): Analyzes prompts against the core LAJBI principles.
  • Interpretation Concept (<interpret>): Explains how the framework parses a prompt.
  • Templating Concept (<template>): Generates best-practice persona templates.

7. Detailed Command Reference

This section serves as the detailed technical reference for the LAJBI framework.

a) Grouped Index of Commands

Core Commands

  • <help>: Displays a list of available commands.
  • <status>: Shows the current system status.
  • <add>: Adds a file to the system's context.
  • <ref>: Initiates an interactive web exploration session.
  • <follow_links>: Continues or concludes a web exploration session.
  • <join>: Adds a single new persona to the team.
  • <load_team>: Loads multiple personas from a file or URL.
  • <leave>: Removes a persona from the team.
  • <team_status>: Lists the current members of the team.
  • <report>: Displays the log of the last team debate.
  • <whisper>: Sends a private, ephemeral message to a single agent.
  • <lecture>: Broadcasts a message to the team for individual learning.
  • ...and more, including context management and diagnostic commands.

Extension Commands

  • <export_state>: Saves a persona's cognitive state (mind) to a file.
  • <import_state>: Loads a persona's cognitive state from a file.
  • <train>: Initiates an automated, multi-step learning session for a persona.
  • <me>: Displays the system's inferred profile of the user.
  • <you>: Displays the cognitive state of an agent.

SYS_AI (Prompting Agent) Commands

  • <evaluate>: Analyzes and scores a prompt against LAJBI principles.
  • <interpret>: Explains how the framework would parse a prompt.
  • <template>: Generates a best-practice persona prompt template.
  • ...and more, including a full suite of prompt refinement tools.

b) Details of Each Existing Command

These commands manage the state of the session, the context, and the team of agents.

<help>

  • Architectural Relation: Core System Utility. Provides user guidance by listing all available operations.
  • Description: Displays a list of available commands, optionally filtered by a group.
  • Example:

    USER: <help> GROUP:Prompting

    SYS_AI:

    Available 'Prompting' Commands:
- <evaluate>
- <interpret>
- <template>
...

<status>

  • Architectural Relation: Core System Utility. Provides a transparent snapshot of the system's dynamic memory.
  • Description: Shows the current system status in a human-readable format.
  • Example:

    USER: <status>

    SYS_AI:

    ### Current System Status

#### Active Team (1 Member)
* developer (Software Developer)

#### Contextual Files (1 Item)
* my_prompt.lbj

<add>

  • Architectural Relation: Context Management. The primary command for loading external data into the system's active memory.
  • Description: Adds a file to the system's context, making it available for other commands.
  • Example:

    USER: <add> FILE:my_team.lbj

    SYS_AI: Ready to receive content for my_team.lbj. Please paste the content now.

<ref>

  • Architectural Relation: Context Management. Initiates a user-controlled, recursive web exploration session.
  • Description: Crawls a URL and presents a numbered list of relevant links for further exploration or ingestion. This command initializes a new EXPLORATION_PATH.
  • Example:

    USER: <ref> URL:https://www.python.org/

    SYS_AI: Crawl complete. The following relevant links were found: 1. [Python Docs](...) - Official language documentation. 2. [PyPI](...) - The Python Package Index.

<follow_links>

  • Architectural Relation: Context Management. The command used to navigate or conclude a web exploration session started by <ref>.
  • Description: Operates in two modes. IDS:[...] explores deeper, presenting a new list of links. INGEST:[...] ingests the entire exploration path into the context.
  • Example:

    USER: <follow_links> INGEST:1,2

    SYS_AI: Acknowledged. Ingesting the full exploration path...

<del>

  • Architectural Relation: Context Management. Removes data from the active memory.
  • Description: Deletes a file or URL from the system's context.
  • Example:

    USER: <del> my_team.lbj

    SYS_AI: Item "my_team.lbj" has been removed from the context.

<import>

  • Architectural Relation: Prompt Modularity. Allows for the modular construction of prompts by merging sections from different files.
  • Description: Finds a module file in the context and merges its content into the currently loading agent's prompt.
  • Example:

    USER: <import> MODULE:general_behaviors.lbj

    SYS_AI: Module 'general_behaviors.lbj' was successfully imported.

<?>

  • Architectural Relation: Core System Utility. A temporary "escape hatch" to bypass the active persona and speak directly to the neutral underlying model.
  • Description: Processes a query while temporarily ignoring all active personas and instructions. The query and response are not stored in memory.
  • Example:

    USER: <?> What is the capital of Mongolia?

    SYS_AI: The capital of Mongolia is Ulaanbaatar.

<forget>

  • Architectural Relation: Core System Utility. A hard reset for the entire session.
  • Description: Resets all internal states, placeholders, and conversational history to their initial state.
  • Example:

    USER: <forget>

    SYS_AI: All states, placeholders, and history have been cleared. System is reset.

<clean>

  • Architectural Relation: Context Management. A soft reset that clears only external data.
  • Description: Clears all external context elements (files and URLs) without resetting personas or history.
  • Example:

    USER: <clean>

    SYS_AI: All external context elements have been removed.

<self>

  • Architectural Relation: Multi-Agent Team Protocol. A command for inspecting an agent's own definition.
  • Description: Displays the full defining prompt for a specified agent or the core system.
  • Example:

    USER: <self> TARGET:developer

    SYS_AI: (Displays the full prompt text for the 'developer' persona inside a code block.)

<join>

  • Architectural Relation: Multi-Agent Team Protocol. The atomic command for adding a single agent to the PERSONAS list.
  • Description: Adds a single new persona to the team from a URL, local file, or raw text.
  • Example:

    USER: <join> TITLE: Historian NAME: Professor_Jones PROMPT: **Role:** You are a world-renowned professor...

    SYS_AI: Persona 'Professor_Jones' has joined the team as 'Historian'.

<load_team>

  • Architectural Relation: Multi-Agent Team Protocol. A utility for the efficient batch-loading of multiple agents.
  • Description: Loads multiple personas from a single file or URL.
  • Example:

    USER: <load_team> FILE:my_team.lbj

    SYS_AI: The following personas were successfully loaded and have joined the team: developer, Tester

<edit_persona>

  • Architectural Relation: Multi-Agent Team Protocol. Allows for the dynamic modification of an agent's prompt.
  • Description: Modifies a section of an existing persona's prompt.
  • Example:

    USER: <edit_persona> NAME:developer TARGET:**Skills:** WITH:["Python", "Django", "SQL"]

    SYS_AI: Persona 'developer' has been successfully modified.

<leave>

  • Architectural Relation: Multi-Agent Team Protocol. Removes an agent from the PERSONAS list.
  • Description: Removes a persona from the team.
  • Example:

    USER: <leave> NAME:Professor_Jones

    SYS_AI: Persona 'Professor_Jones' has left the team.

<team_status>

  • Architectural Relation: Multi-Agent Team Protocol. A command for viewing the current state of the PERSONAS list.
  • Description: Lists the current members of the team.
  • Example:

    USER: <team_status>

    SYS_AI:

    ### Active Team (2 Members)
* developer (Software Developer)
* Tester (QA Tester)

<report>

  • Architectural Relation: Team Interaction Protocol. Provides a transparent window into the internal debate process.
  • Description: Displays the log of the last team debate.
  • Example:

    USER: <report> DETAIL:FULL

    SYS_AI: (Displays the full turn-by-turn debate transcript and individual hypotheses.)

<CoT>

  • Architectural Relation: PABIAM Cognitive Architecture. Explicitly toggles the Chain of Thought reasoning process.
  • Description: Activates or deactivates Chain of Thought reasoning.
  • Example:

    USER: <CoT> COT_STATUS:ON

    SYS_AI: Chain of Thought reasoning is now active.

<whisper>

  • Architectural Relation: Multi-Agent Team Protocol. Enables private, off-the-record communication.
  • Description: Sends a private, ephemeral message to a single agent. Alias: !@<name>.
  • Example:

    USER: !@developer Is this the most efficient algorithm?

    developer: (Privately) No, a recursive solution would be more elegant but harder to debug.

<lecture>

  • Architectural Relation: Multi-Agent Team Protocol. Enables a didactic broadcast for team-wide learning.
  • Description: Broadcasts a message to all team members for individual PABIAM state updates. Alias: !@team.
  • Example:

    USER: !@team All future code must be compliant with the new security protocol.

    developer: Acknowledged. Tester: Understood. I will add that to my review checklist.

Extension Commands: Advanced Capabilities

These commands add powerful features for learning, adaptation, and persistence.

<export_state>

  • Architectural Relation: PABIAM Cognitive Architecture. Allows you to serialize an agent's entire cognitive state for persistence.
  • Description: Saves a persona's PABIAM cognitive state to a JSON file.
  • Example:

    USER: <export_state> TARGET:developer FILENAME:developer_mind.json

    SYS_AI: (Displays a JSON object representing the developer persona's beliefs, intentions, etc.)

<import_state>

  • Architectural Relation: PABIAM Cognitive Architecture. Restores an agent's "memory" by deserializing a saved cognitive state.
  • Description: Loads a persona's PABIAM state from a JSON file.
  • Example:

    USER: <import_state> TARGET:developer FILE:developer_mind.json

    SYS_AI: Successfully restored PABIAM state for persona 'developer'.

<refine_prompt_from_state>

  • Architectural Relation: PABIAM / Systematic Refinement. Creates a feedback loop where an agent's learned beliefs can be used to permanently improve its own core prompt.
  • Description: Analyzes an agent's PABIAM state and proposes an <edit_persona> command to codify its learned knowledge.
  • Example:

    USER: <refine_prompt_from_state>

    SYS_AI: Proposed refinement: <edit_persona> NAME:developer TARGET:**Role specific behavior...** WITH:["Always use type hints for function signatures."]

<train>

  • Architectural Relation: Fine-Tuning Through Training / PABIAM. Automates a learning loop where a persona updates its PABIAM BELIEF_REPOSITORY based on source material.
  • Description: Initiates an automated, multi-step learning session for a persona using the "Spectrum of Emulation."
  • Example:

    USER: <train> PERSONA:developer WITH:https://peps.python.org/pep-0008/ ACCURACY_TARGET:Embodiment

    SYS_AI: Starting training for 'developer'... (Generates a Training Summary Report.)

<updatemeta>

  • Architectural Relation: Core System Utility. The command for modifying the live meta-prompting instructions of the framework itself.
  • Description: Performs a full or partial update of the core, extension, or specific meta-prompting instructions.
  • Example:

    USER: <updatemeta> TARGET:<help> WITH:[New definition for the help command]

    SYS_AI: Partial update successful. The definition for <help> has been modified.

<me>

  • Architectural Relation: User Model and Adaptive Behavior Protocol. Provides a transparent view into the user profile the AI agents are maintaining.
  • Description: Displays the AI's inferred profile of your communication style and preferences.
  • Example:

    USER: <me>

    SYS_AI: **User Analytics:** * **Communication Style:** Direct, command-based...

<you>

  • Architectural Relation: PABIAM Cognitive Architecture. The primary command for introspecting the live cognitive state of any agent.
  • Description: Displays the PABIAM cognitive state of an agent.
  • Example:

    USER: <you> TARGET:developer STATE:BELIEF

    SYS_AI:

    **Belief Repository for 'developer':**
- Proposition: "Type hints improve code maintainability." (CONFIDENCE:95)

SYS_AI (Prompting Agent) Commands

These commands are unique to the SYS_AI persona, designed to help you build better prompts.

<make>

  • Architectural Relation: Templating Concept. An interactive wizard for building a new persona prompt from scratch.
  • Description: Guides you through the creation of a new prompt by asking for each mandatory section.
  • Example:

    USER: <make> ROLE:A project manager

    SYS_AI: Acknowledged. Role is "A project manager." Now, please provide the **Task:** for this persona.

<interpret>

  • Architectural Relation: Interpretation Concept. Explains how the framework's parser "sees" your prompt.
  • Description: Parses a prompt and explains how the LAJBI framework would understand its structure.
  • Example:

    USER: <interpret> PROMPT:**Role:** a bot

    SYS_AI: I would interpret this as a minimal persona definition...

<evaluate>

  • Architectural Relation: Evaluation Concept. Uses the "Main Principles of Good Prompting" as a scorecard to analyze your prompts.
  • Description: Analyzes a prompt and provides a scored report with actionable feedback.
  • Example:

    USER: <evaluate> PROMPT:**Role:** a bot

    SYS_AI: (Displays a table rating the prompt against LAJBI principles.)

<enhance>

  • Architectural Relation: Systematic Refinement. The first step in a two-stage commit process for safely modifying a prompt.
  • Description: Stages a proposed change to a prompt without applying it permanently.
  • Example:

    USER: <enhance> SECTION:**Role:** WITH:[A new, more detailed role description]

    SYS_AI: Changes have been staged. Use <commit> to apply or <discard> to cancel.

<commit>

  • Architectural Relation: Systematic Refinement. Finalizes changes made with <enhance>.
  • Description: Applies the staged changes to the active prompt.
  • Example:

    USER: <commit>

    SYS_AI: Staged changes have been committed.

<discard>

  • Architectural Relation: Systematic Refinement. Reverts changes made with <enhance>.
  • Description: Discards any staged changes.
  • Example:

    USER: <discard>

    SYS_AI: Staged changes have been discarded.

<merge>

  • Architectural Relation: Prompt Modularity. Intelligently combines elements from two different prompts.
  • Description: Merges key elements from a source prompt into the currently evaluated prompt.
  • Example:

    USER: <merge> WITH:another_prompt.lbj

    SYS_AI: Successfully merged elements from 'another_prompt.lbj'.

<reformat>

  • Architectural Relation: Optimal Formatting. An automated tool to clean up prompt syntax.
  • Description: Applies standard formatting, indentation, and spelling/grammar fixes to a prompt.
  • Example:

    USER: <reformat> PROMPT:[A poorly formatted prompt...]

    SYS_AI: (Displays the same prompt with corrected formatting and grammar.)

<optimize>

  • Architectural Relation: Principle of Economy. Analyzes a prompt for ways to reduce token count without losing effectiveness.
  • Description: Analyzes a prompt and proposes changes to make it more token-efficient.
  • Example:

    USER: <optimize> PROMPT:[A verbose prompt...]

    SYS_AI: (Displays a table with suggestions for making the prompt more concise.)

<apply_fix>

  • Architectural Relation: Systematic Refinement. A command to directly apply suggestions generated by <evaluate> or <optimize>.
  • Description: Applies a specific numbered improvement from the last evaluation.
  • Example:

    USER: <apply_fix> ID:1

    SYS_AI: Applying fix #1... (Displays the rewritten prompt.)

<compare>

  • Architectural Relation: Evaluation Concept. Provides a side-by-side analysis of two different prompts against LAJBI principles.
  • Description: Analyzes two prompts and provides a comparative analysis and recommendation.
  • Example:

    USER: <compare> PROMPT_A:prompt1.lbj PROMPT_B:prompt2.lbj

    SYS_AI: (Displays a markdown table comparing the two prompts.)

<template>

  • Architectural Relation: Templating Concept. Generates pre-structured persona skeletons.
  • Description: Generates a best-practice persona prompt template for a common archetype.
  • Example:

    USER: <template> TYPE:Project Manager

    SYS_AI: (Generates a complete, well-structured prompt template.)

<get_principle_detail>

  • Architectural Relation: Core Principles. Provides on-demand documentation for the framework's guiding principles.
  • Description: Provides a detailed explanation of a specific prompting principle.
  • Example:

    USER: <get_principle_detail> PRINCIPLE:Agentic Qualities

    SYS_AI: (Provides a detailed explanation of the "Agentic Qualities" principle.)

<extend>

  • Architectural Relation: Prompt Modularity. Allows for compositional persona creation by layering capabilities from multiple prompt files.
  • Description: This command enhances an active persona by intelligently merging capabilities from a secondary prompt file. It locates the target persona, parses the extension prompt, and appends the content of each section in the extension to the corresponding section in the target persona. If a section does not exist in the target, it is created.
  • Example:

    USER: <extend> TARGET:developer WITH:python_skills.ljb

    SYS_AI: Persona 'developer' has been successfully extended with capabilities from 'python_skills.ljb'.

<instruct>

  • Architectural Relation: Core System Utility / Workflow Automation. The primary command for executing complex, multi-step automated tasks.
  • Description: Executes a sequential list of instructions as an automated workflow. The agent receiving the command analyzes the plan, proposes a more granular sub-plan for complex steps, and awaits user confirmation before execution. Individual steps can be routed to other agents by prefixing the instruction with @<name>.
  • Example:

    USER: <instruct> INSTRUCTIONS:[@Dev write the function., @Testa write the unit tests., @Dev document the code.]

    SYS_AI: (Analyzes the plan and awaits confirmation before executing the three-step workflow.)

<rerun_step>

  • Architectural Relation: Workflow Automation. Provides an iterative refinement loop for tasks executed with <instruct>.
  • Description: Re-executes a single, specific step of an active workflow using new instruction text. The output of the re-run step overwrites the original output, and the final consolidated document is immediately updated.
  • Example:

    USER: <rerun_step> STEP:1 WITH:Rewrite the function to be more memory efficient.

    SYS_AI: Step 1 has been re-run. The final document has been updated.

<synthesize>

  • Architectural Relation: Workflow Automation / Systematic Refinement. A meta-command that creates an optimized workflow from a completed conversation.
  • Description: Analyzes the entire conversational history to find the most efficient path to the final outcome. It prunes all dead ends and superseded instructions to generate a single, clean, and optimized <instruct> command that can replicate the final result in one automated step.
  • Example:

    USER: <synthesize> NAME:Final API Workflow

    SYS_AI: (Analyzes the conversation and outputs a single, comprehensive <instruct> command in a markdown code block.)

Clone this wiki locally