Cognotik | CognitiveMode

⚙️ OrchestrationConfig.json


{
  "type": "AdaptivePlanningMode",
  "schema_strategy": "ScientificMethod",
  "auto_fix": true,
  "model_config": {
    "smart": "gpt-4-turbo",
    "fast": "gpt-3.5-turbo"
  }
}

→

🧠 Live Transcript

State: Hypothesis Testing

graph TD A[Analyze Error] --> B{Hypothesis?} B -->|Network| C[Check DNS] B -->|Code| D[Run Linter] C --> E[Refute Hypothesis] E --> A

Thinking: Network checks passed. Switching strategy to Code Analysis.

Executing: RunCodeTask...

Cognotik ships with four distinct architectural patterns for problem-solving.

Mode Name	Architecture	Best Use Case
WaterfallMode	`Plan -> Review -> Execute`	Well-defined problems where the user must approve the entire roadmap.
ConversationalMode	`Listen -> Act -> Reply`	Interactive debugging or simple "Chat with Code" workflows.
AdaptivePlanningMode	`Loop(Think -> Act -> Reflect)`	Complex, ambiguous goals requiring research and self-correction.
HierarchicalPlanningMode	`Tree(Decompose -> Delegate)`	Massive projects. Breaks goals into sub-goals and spawns sub-tasks.

Strategy	Internal State	Reasoning Style
Project Manager	`ReasoningState`	Generalist. Tracks short-term vs. long-term goals.
Scientific Method	`ScientificState`	Debugger. Formulates hypotheses and tracks established facts.
Agile Developer	`AgileState`	Coder. Follows TDD loop: Test Failing -> Implementing -> Refactoring.
Critical Auditor	`AuditState`	Security. Adversarial mindset designed to find flaws.

To create a custom mode, implement the run() loop. You must handle state updates and UI rendering.


class MyCustomMode(val config: OrchestrationConfig) {
    fun run(task: SessionTask, userPrompt: String, availableTasks: List) {
        // 1. Initialize Strategy (The "Brain")
        val strategy = CognitiveSchemaStrategy.ScientificMethod
        var state = strategy.initialize(userPrompt, config.defaultSmart)

        // 2. Execution Loop
        while (!state.isComplete()) {
            // A. Get Guidance
            val guidance = strategy.getTaskSelectionGuidance(state)

            // B. Select & Execute Task
            val tool = availableTasks.first { it.canHandle(guidance) }
            val result = tool.execute(task.ui, guidance, config)

            // C. Update State (Reflection)
            state = strategy.update(state, result, config.defaultSmart)

            // D. Observability
            task.transcript()?.write("## Step Complete: ${state.currentPhase}\n".toByteArray())
        }
        task.complete("Goal Achieved")
    }
}

Integration Guide

Configuration

Reference the mode in your OrchestrationConfig. Note that the type field drives polymorphic deserialization.


val config = OrchestrationConfig(
    // Select the architectural mode (Maps to CognitiveModeConfig.type)
    type = CognitiveModeType.AdaptivePlanningMode,

    // Inject the reasoning strategy
    overrides = mapOf(
        "schema_strategy" to "AgileDeveloper"
    ),

    // Define autonomy level
    autoFix = true
)

Observability Standards

All modes must adhere to the Transparency First principle:

Mermaid Diagrams: Visualize the state machine in the transcript.
Collapsed Details: Use <details> tags for raw JSON state dumps.
Graceful Degradation: Catch LLM hallucinations and attempt to simplify prompts before failure.