Cognotik | Cognitive Modes

⚙️ OrchestrationConfig.json

{
  "mode": "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 requiring user approval of the 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 requiring sub-goal decomposition.

Strategy	Internal State	Reasoning Style
Project Manager	`ReasoningState`	Generalist. Tracks short-term vs. long-term goals.
Scientific Method	`ScientificState`	Debugger. Formulates hypotheses and tracks facts.
Agile Developer	`AgileState`	Coder. Follows TDD loop: Test -> Implement -> Refactor.
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 manually.

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

To use a specific mode, reference it in your OrchestrationConfig. The resulting execution plan is stored in the Tasks data structure.

val config = OrchestrationConfig(
    // Select the architectural mode
    mode = CognitiveMode.AdaptivePlanningMode,

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

    // Define autonomy level
    autoFix = true
)

Implementation Note: Tasks.kt

The Tasks class acts as the container for the MutableList<TaskExecutionConfig> generated by the Cognitive Mode. It ensures that every task in the sequence is validated before execution.