Cognotik | CognitiveMode

⚙️ 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...

Architectural Patterns

Cognotik implements several distinct modes for orchestrating agent behavior.

Mode Name	Architecture	Best Use Case
Adaptive	`Loop(Think -> Act -> Reflect)`	Complex, ambiguous goals requiring research and self-correction.
Coding	`TDD / Refactor Loop`	Software engineering tasks, bug fixing, and feature implementation.
Waterfall	`Plan -> Review -> Execute`	Well-defined problems requiring user approval of the roadmap.
Chat	`Listen -> Act -> Reply`	Interactive debugging or simple "Chat with Code" workflows.
Hierarchical	`Tree(Decompose -> Delegate)`	Massive projects requiring sub-goal decomposition.
Parallel	`Fan-out -> Aggregate`	High-throughput independent tasks or batch processing.
Council	`Multi-agent Consensus`	High-stakes decision making and adversarial review.
Protocol	`Step-by-step Validation`	Compliance and safety-critical workflows.
PersonaChat	`Role-play Interaction`	Specialized domain expertise and persona-driven assistance.

Strategy	Internal State	Reasoning Style
Project Manager	`ReasoningState`	Generalist. Tracks goals and manages a task queue.
Scientific Method	`ScientificState`	Debugger. Formulates hypotheses and attempts to falsify theories.
Agile Developer	`AgileState`	Coder. Follows Test-Driven Development loops.
Critical Auditor	`AuditState`	Security. Adversarial mindset designed to find flaws.

Implementation Skeleton

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


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

Reference your mode in the OrchestrationConfig.


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

    // Inject the reasoning strategy (if supported by the mode)
    overrides = mapOf(
        "schema_strategy" to "AgileDeveloper"
    ),

    // Define autonomy level
    autoFix = true
)

Observability Standards

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 prompt simplification.

State: Hypothesis Testing

Architectural Patterns

Cognitive Schema Strategies

Implementation Skeleton

Integration Guide

Observability Standards