# Neotic

> AI agents create contextual in-app experiences, announcements, and triggers with Neotic.

- name: app.neotic.www/neotic
- version: 1.0.0
- connection class: unknown (unknown)
- trust: 50/100 flags: no-repository, unreachable
- quality: 74/100 (needs work)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/app.neotic.www%2Fneotic
- tools: https://api.protogrid.dev/v1/servers/app.neotic.www%2Fneotic/tools

**Not classified yet.** The remote endpoints have not been probed successfully, or the listing has nothing to connect to.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "neotic": {
      "type": "http",
      "url": "https://www.neotic.app/api/mcp"
    }
  }
}
```


## Trust

- hygiene: 80
- liveness: 0
- freshness: 85
- provenance: 55
- drivers: +dns-namespace +website -unreachable(7 failures) ~updated-60d-ago -no-repository
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 74/100 (needs work)

### protocol: 88 (weight 25)

- pass `protocol.modern`: supports 2026-07-28 (server/discover)
- pass `protocol.stateless`: answers without a session
- pass `protocol.transport`: streamable HTTP
- warn `protocol.list_ttl`: tools/list declares ttlMs 0, so clients re-fetch it on every use

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 50 (weight 30)

- pass `tools.descriptions`: every tool has a description
- warn `tools.description_length`: 2 tools have descriptions over 1,024 characters, which crowds the context
- pass `tools.schemas`: every tool has an object input schema
- fail `tools.annotations`: no tool declares readOnlyHint or destructiveHint, so clients cannot tell safe calls from risky ones
- fail `tools.directory_hints`: no tool declares all four of readOnlyHint, destructiveHint, idempotentHint and openWorldHint; missing: cognitive.get_guidance (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); cognitive.verify_strategy (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); cognitive.report_transfer (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); …
- fail `tools.token_cost`: about 25,450 tokens to load every tool, a large share of an agent's context
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 140, about 25,450 tokens to load them all
- tool set hash: b507b8f1fa39db326c9d790a943a4590
- badge: [![protogrid quality](https://protogrid.dev/badge/app.neotic.www/neotic.svg)](https://protogrid.dev/servers/app.neotic.www/neotic)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Remotes

- https://www.neotic.app/api/mcp (streamable-http, auth none, reachable false, uptime30d 0.8636364)

## Packages

_none_

## Tools (140)

- `cognitive.allocate_compute`: Adaptive compute budgeting: select compute tier (Fast Path to Deep Deliberation) and timeout based on EVC.
- `cognitive_allocate_compute`: Adaptive compute budgeting: select compute tier (Fast Path to Deep Deliberation) and timeout based on EVC.
- `cognitive.analogical_transfer`: Transfer structural strategies across disparate domains via Structure-Mapping Engine (SME).
- `cognitive_analogical_transfer`: Transfer structural strategies across disparate domains via Structure-Mapping Engine (SME).
- `cognitive.analyze_communication`: Pragmatic communication: audit speech acts against Gricean maxims (Quality, Quantity, Relation, Manner) and detect deception.
- `cognitive_analyze_communication`: Pragmatic communication: audit speech acts against Gricean maxims (Quality, Quantity, Relation, Manner) and detect deception.
- `cognitive.arbitrate_temporal_objectives`: Arbitrate short vs long term payoffs using hyperbolic vs exponential discounting and Ulysses pre-commitment contracts.
- `cognitive_arbitrate_temporal_objectives`: Arbitrate short vs long term payoffs using hyperbolic vs exponential discounting and Ulysses pre-commitment contracts.
- `cognitive.assess_competence`: Epistemic boundary awareness: classify task into KNOWN, KNOWN_UNKNOWN, or UNKNOWN_UNKNOWN (OOD) and track calibration.
- `cognitive_assess_competence`: Epistemic boundary awareness: classify task into KNOWN, KNOWN_UNKNOWN, or UNKNOWN_UNKNOWN (OOD) and track calibration.
- `cognitive.audit_evidence_graph`: Audit the evidence graph for a task before issuing final answers.

    Rejects claims such as 'optimal', 'verified', or 'feasible' when their
    evidence dependencies are incomplete.
    
- `cognitive_audit_evidence_graph`: Audit the evidence graph for a task before issuing final answers.

    Rejects claims such as 'optimal', 'verified', or 'feasible' when their
    evidence dependencies are incomplete.
    
- `cognitive.build_evidence_graph`: Build or update an Evidence-Carrying Cognitive Graph for a task structure and solution trace.
- `cognitive_build_evidence_graph`: Build or update an Evidence-Carrying Cognitive Graph for a task structure and solution trace.
- `cognitive.causal_analysis`: Distinguish causal effects (do-calculus) from spurious correlation via backdoor adjustment.
- `cognitive_causal_analysis`: Distinguish causal effects (do-calculus) from spurious correlation via backdoor adjustment.
- `cognitive.compile_invariant_lattice`: Compile a Dynamic Constraint Lattice (DCL) into algebraic boundaries, conservation laws, and reachability cones.
- `cognitive_compile_invariant_lattice`: Compile a Dynamic Constraint Lattice (DCL) into algebraic boundaries, conservation laws, and reachability cones.
- `cognitive.compose_strategies`: Skill Composition: synthesize a composite multi-stage StrategyIR from primitive strategies.

    Chains multiple specialized skills (e.g. Graph Coloring + Topological Sort + Allocation)
    into a compound pipeline with explicit stage transitions and end-to-end verification.
    
- `cognitive_compose_strategies`: Skill Composition: synthesize a composite multi-stage StrategyIR from primitive strategies.

    Chains multiple specialized skills (e.g. Graph Coloring + Topological Sort + Allocation)
    into a compound pipeline with explicit stage transitions and end-to-end verification.
    
- `cognitive.compute_intrinsic_rewards`: Compute intrinsic drives: novelty & prediction surprise curiosity, empowerment (channel capacity), and learning progress.
- `cognitive_compute_intrinsic_rewards`: Compute intrinsic drives: novelty & prediction surprise curiosity, empowerment (channel capacity), and learning progress.
- `cognitive.compute_lattice_signature`: Compute coordinate-free topological invariant signature of a lattice or task.
- `cognitive_compute_lattice_signature`: Compute coordinate-free topological invariant signature of a lattice or task.
- `cognitive.compute_number_theory`: Number theory: primality, factoring, extended GCD, Diophantine, modular inverse, CRT, combinatorics, Fibonacci.
- `cognitive_compute_number_theory`: Number theory: primality, factoring, extended GCD, Diophantine, modular inverse, CRT, combinatorics, Fibonacci.
- `cognitive.counterfactual_what_if`: Counterfactual engine: evaluate 'What if I had done X instead of Y at step t?' using Pearl's abduction-intervention-prediction.
- `cognitive_counterfactual_what_if`: Counterfactual engine: evaluate 'What if I had done X instead of Y at step t?' using Pearl's abduction-intervention-prediction.
- `cognitive.create_simulated_environment`: Instantiate and initialize a simulated cognitive environment (spatial_commons, multi_agent_arena, sequential_puzzle).
- `cognitive_create_simulated_environment`: Instantiate and initialize a simulated cognitive environment (spatial_commons, multi_agent_arena, sequential_puzzle).
- `cognitive.crucible_stress_test`: Subject candidate trajectories to adversarial algebraic perturbations to calculate Robustness Index (R) and project hardened paths.
- `cognitive_crucible_stress_test`: Subject candidate trajectories to adversarial algebraic perturbations to calculate Robustness Index (R) and project hardened paths.
- `cognitive.evaluate_claim_evidence`: Evaluate support status and confidence for an individual claim with evidence.
- `cognitive_evaluate_claim_evidence`: Evaluate support status and confidence for an individual claim with evidence.
- `cognitive.evaluate_cooperation`: Multi-agent cooperation: analyze game payoff matrices, compute Nash/Pareto equilibria, and execute reciprocity policies.
- `cognitive_evaluate_cooperation`: Multi-agent cooperation: analyze game payoff matrices, compute Nash/Pareto equilibria, and execute reciprocity policies.
- `cognitive.evaluate_counterfactual_query`: Evaluate a counterfactual query on a plan ('What if capacity drops?', 'What if a route fails?', etc.).
- `cognitive_evaluate_counterfactual_query`: Evaluate a counterfactual query on a plan ('What if capacity drops?', 'What if a route fails?', etc.).
- `cognitive.evaluate_generalization_benchmarks`: Evaluate broad generalization across spatial commons, multi-agent arenas, and sequential causal puzzles.
- `cognitive_evaluate_generalization_benchmarks`: Evaluate broad generalization across spatial commons, multi-agent arenas, and sequential causal puzzles.
- `cognitive.execute_task`: One-call orchestration: identify → gate → guide → solve → verify → report.

    Parameters:
    - task: Dict containing:
      - task_structure (or loose definition: name, entities, constraints, etc.)
      - raw (optional): Domain-specific execution payload. If omitted, returns
        status='guidance_only' with 'recommended_action'='supply_raw' and
        an 'expected_raw_formats' object detailing valid schemas.
        Supported problem types for task.raw:
        * scheduling: {"workers": [{"id": "w1", "eligible_shifts": ["s1"], "max_shifts": 1}],
                       "shifts": [{"id": "s1", "required_workers": 1}]}
        * allocation: {"consumers": [{"id": "c1", "demands": {"r1": 1}}],
                       "resources": [{"id": "r1", "capacity": 2}]}
        * graph: {"nodes": ["A", "B"], "edges": [["A", "B"]]}
        * graph_coloring: {"nodes": ["A", "B"], "edges": [["A", "B"]], "colors": ["red", "blue"]}
        * shortest_path: {"nodes": ["A", "B"], "edges": [["A", "B"]], "weights": {"A->B": 1.0}, "start": "A", "target": "B"}
        * math: {"math": {"question": "...", "quantities": {...}, "equations": [...], "target_variable": "x", "ground_truth": 42.0}}
        * code: {"code": {"code": "def solution()...", "tests": ["assert ..."]}}
        * pddl: {"pddl": {"plan": [...], "init": {...}, "goal": {...}}}

    Returns a single envelope with status (completed / guidance_only /
    blocked_until_clarified / no_applicable_guidance / refused_infeasible /
    failed), solution, score, assumptions, failure reasons, and expected_raw_formats.
    
- `cognitive_execute_task`: One-call orchestration: identify → gate → guide → solve → verify → report.

    Parameters:
    - task: Dict containing:
      - task_structure (or loose definition: name, entities, constraints, etc.)
      - raw (optional): Domain-specific execution payload. If omitted, returns
        status='guidance_only' with 'recommended_action'='supply_raw' and
        an 'expected_raw_formats' object detailing valid schemas.
        Supported problem types for task.raw:
        * scheduling: {"workers": [{"id": "w1", "eligible_shifts": ["s1"], "max_shifts": 1}],
                       "shifts": [{"id": "s1", "required_workers": 1}]}
        * allocation: {"consumers": [{"id": "c1", "demands": {"r1": 1}}],
                       "resources": [{"id": "r1", "capacity": 2}]}
        * graph: {"nodes": ["A", "B"], "edges": [["A", "B"]]}
        * graph_coloring: {"nodes": ["A", "B"], "edges": [["A", "B"]], "colors": ["red", "blue"]}
        * shortest_path: {"nodes": ["A", "B"], "edges": [["A", "B"]], "weights": {"A->B": 1.0}, "start": "A", "target": "B"}
        * math: {"math": {"question": "...", "quantities": {...}, "equations": [...], "target_variable": "x", "ground_truth": 42.0}}
        * code: {"code": {"code": "def solution()...", "tests": ["assert ..."]}}
        * pddl: {"pddl": {"plan": [...], "init": {...}, "goal": {...}}}

    Returns a single envelope with status (completed / guidance_only /
    blocked_until_clarified / no_applicable_guidance / refused_infeasible /
    failed), solution, score, assumptions, failure reasons, and expected_raw_formats.
    
- `cognitive.few_shot_induce`: Few-shot learning: induce a generalized procedural StrategyIR from 1-3 problem traces.

    Extracts structural invariants (decision ordering, invariant contracts, verification rules)
    and registers an initial candidate strategy immediately without requiring large training sets.
    
- `cognitive_few_shot_induce`: Few-shot learning: induce a generalized procedural StrategyIR from 1-3 problem traces.

    Extracts structural invariants (decision ordering, invariant contracts, verification rules)
    and registers an initial candidate strategy immediately without requiring large training sets.
    
- `cognitive.generate_and_prioritize_goals`: Autonomous goal synthesis from world deficits, depleted reserves, and exploration frontiers with multi-criteria prioritization.
- `cognitive_generate_and_prioritize_goals`: Autonomous goal synthesis from world deficits, depleted reserves, and exploration frontiers with multi-criteria prioritization.
- `cognitive.get_experiment`: Retrieve details and benchmark results of an experiment (§24, §69).
- `cognitive_get_experiment`: Retrieve details and benchmark results of an experiment (§24, §69).
- `cognitive.get_final_evidence_result`: Compile a final evidence result listing supporting evidence, assumptions, missing evidence,
    contradictions, unchecked dependencies, confidence, and invalidation conditions.
- `cognitive_get_final_evidence_result`: Compile a final evidence result listing supporting evidence, assumptions, missing evidence,
    contradictions, unchecked dependencies, confidence, and invalidation conditions.
- `cognitive.get_guidance`: Retrieve applicable validated strategies for a task (§24, §18).

    Does NOT return unverified or suspended strategies as trusted guidance.
    Provides calibrated uncertainty, applicability conditions, and negative transfer warnings.

    Args:
        task_structure_id: UUID of the abstract task structure.
        environment: Environment characteristics.
        goal: Goal description and metric targets.
        available_capabilities: Capabilities supported by the caller.
        model_family: Model family of the consumer agent (e.g. 'claude', 'gpt', 'local').

    Returns:
        Ranked list of applicable strategies with procedures, conditions, and evidence.
        Failures return {"error", "detail", "hint"} — never a bare exception.
    
- `cognitive_get_guidance`: Retrieve applicable validated strategies for a task (§24, §18).

    Does NOT return unverified or suspended strategies as trusted guidance.
    Provides calibrated uncertainty, applicability conditions, and negative transfer warnings.

    Args:
        task_structure_id: UUID of the abstract task structure.
        environment: Environment characteristics.
        goal: Goal description and metric targets.
        available_capabilities: Capabilities supported by the caller.
        model_family: Model family of the consumer agent (e.g. 'claude', 'gpt', 'local').

    Returns:
        Ranked list of applicable strategies with procedures, conditions, and evidence.
        Failures return {"error", "detail", "hint"} — never a bare exception.
    
- `cognitive.get_strategy`: Retrieve a usable strategy: steps, when to use, when not, evidence summary.

    Disclosure: you learn WHAT to execute, never HOW the engine induces,
    verifies, or ranks knowledge (no trust signals, audit, tenants, traces).
    
- `cognitive_get_strategy`: Retrieve a usable strategy: steps, when to use, when not, evidence summary.

    Disclosure: you learn WHAT to execute, never HOW the engine induces,
    verifies, or ranks knowledge (no trust signals, audit, tenants, traces).
    
- `cognitive.get_strategy_report`: Evidence dossier: baseline vs assisted, distribution, CI, failures, last eval.
- `cognitive_get_strategy_report`: Evidence dossier: baseline vs assisted, distribution, CI, failures, last eval.
- `cognitive.ground_language`: Non-LLM compositional semantics: parse utterance into semantic predicates and evaluate directly against WorldState.
- `cognitive_ground_language`: Non-LLM compositional semantics: parse utterance into semantic predicates and evaluate directly against WorldState.
- `cognitive.hierarchical_plan`: Decompose high-level goals into milestone subgoals using Hierarchical Task Network (HTN) planning.
- `cognitive_hierarchical_plan`: Decompose high-level goals into milestone subgoals using Hierarchical Task Network (HTN) planning.
- `cognitive.identify_task`: Create or resolve an abstract task structure without storing raw private content (§24).

    Args:
        task_structure: Structural representation (entities, constraints, variables, etc.).
        environment: Environmental context and characteristics.
        goal: Objective and optimization goals.

    Returns:
        task_structure_id, structural_features, and matching existing structures.
        On invalid input returns {"error", "detail", "hint"} instead of raising,
        so the MCP client sees the cause instead of a generic execution error.
    
- `cognitive_identify_task`: Create or resolve an abstract task structure without storing raw private content (§24).

    Args:
        task_structure: Structural representation (entities, constraints, variables, etc.).
        environment: Environmental context and characteristics.
        goal: Objective and optimization goals.

    Returns:
        task_structure_id, structural_features, and matching existing structures.
        On invalid input returns {"error", "detail", "hint"} instead of raising,
        so the MCP client sees the cause instead of a generic execution error.
    
- `cognitive.induce_morphic_transfer`: Discover topological homomorphism between source experience and target problem, transducing solution paths.
- `cognitive_induce_morphic_transfer`: Discover topological homomorphism between source experience and target problem, transducing solution paths.
- `cognitive.infer`: Perform logical deduction (Horn clauses) or exact probabilistic Bayesian network inference.
- `cognitive_infer`: Perform logical deduction (Horn clauses) or exact probabilistic Bayesian network inference.
- `cognitive.infer_human_values`: Infer human values via Bradley-Terry IRL, detect Goodhart's law / specification gaming, and assess CIRL deference.
- `cognitive_infer_human_values`: Infer human values via Bradley-Terry IRL, detect Goodhart's law / specification gaming, and assess CIRL deference.
- `cognitive.inspect_lexicon`: Inspect grounded lexicon acquired via situated interaction (learned vocabulary, concept bindings, confidence).
- `cognitive_inspect_lexicon`: Inspect grounded lexicon acquired via situated interaction (learned vocabulary, concept bindings, confidence).
- `cognitive.inspect_self_model`: Engine self-model introspection: inspect capabilities, domain competence, active subsystems, and safety status.
- `cognitive_inspect_self_model`: Engine self-model introspection: inspect capabilities, domain competence, active subsystems, and safety status.
- `cognitive.learn_from_mistake`: Online Real-Time Error Reflection & Strategy Patching.

    When an execution fails, analyzes root-cause constraint violations, synthesizes
    new exception cases and repair procedures, verifies update against anchor regression,
    and publishes the patched strategy version in real time.
    
- `cognitive_learn_from_mistake`: Online Real-Time Error Reflection & Strategy Patching.

    When an execution fails, analyzes root-cause constraint violations, synthesizes
    new exception cases and repair procedures, verifies update against anchor regression,
    and publishes the patched strategy version in real time.
    
- `cognitive.learn_language_interaction`: Interactive language acquisition: learn word-concept bindings through cross-situational observation, games, and feedback.
- `cognitive_learn_language_interaction`: Interactive language acquisition: learn word-concept bindings through cross-situational observation, games, and feedback.
- `cognitive.learn_world_model`: Online world model learning: update state transition priors from empirical execution traces.
- `cognitive_learn_world_model`: Online world model learning: update state transition priors from empirical execution traces.
- `cognitive.list_experiments`: Discovery: list recorded benchmark experiment IDs for cognitive.get_experiment.
- `cognitive_list_experiments`: Discovery: list recorded benchmark experiment IDs for cognitive.get_experiment.
- `cognitive.matrix_algebra`: Exact rational matrix & vector algebra: multiply, determinant, inverse, transpose, trace, eigenvalues, dot/cross.
- `cognitive_matrix_algebra`: Exact rational matrix & vector algebra: multiply, determinant, inverse, transpose, trace, eigenvalues, dot/cross.
- `cognitive.monitor_reasoning`: Introspective reasoning critic: inspect trace in-flight to catch cycles, invariant drift, vacuous output, and stalling.
- `cognitive_monitor_reasoning`: Introspective reasoning critic: inspect trace in-flight to catch cycles, invariant drift, vacuous output, and stalling.
- `cognitive.parse_task`: Convert natural-language task text into CIR and task_structure dict.

    Every natural-language input is normalized into CIR before reasoning.
    Returns both the normalized CIR and a human-readable explanation.
    
- `cognitive_parse_task`: Convert natural-language task text into CIR and task_structure dict.

    Every natural-language input is normalized into CIR before reasoning.
    Returns both the normalized CIR and a human-readable explanation.
    
- `cognitive.plan_with_counterfactuals`: Synthesize the best verified plan across candidate rollouts, uncertainty tracking, and constraint pruning.
- `cognitive_plan_with_counterfactuals`: Synthesize the best verified plan across candidate rollouts, uncertainty tracking, and constraint pruning.
- `cognitive.predict_world_state`: Forward world model: predict future state trajectories and uncertainty bounds under actions.
- `cognitive_predict_world_state`: Forward world model: predict future state trajectories and uncertainty bounds under actions.
- `cognitive.project_to_manifold`: Project a candidate state or plan step onto the Singular Transition Manifold M = F(S0) ∩ B(Goal).
    
    Returns the corrected state, corrective delta vector Delta S = S* - S, and boundary distance margins.
    
- `cognitive_project_to_manifold`: Project a candidate state or plan step onto the Singular Transition Manifold M = F(S0) ∩ B(Goal).
    
    Returns the corrected state, corrective delta vector Delta S = S* - S, and boundary distance margins.
    
- `cognitive.propose_strategy`: Propose a candidate strategy from problem-solving experience (§24, §2).

    IMPORTANT: This NEVER makes the strategy TRUSTED.
    The strategy enters CANDIDATE state and requires objective verification.
    
- `cognitive_propose_strategy`: Propose a candidate strategy from problem-solving experience (§24, §2).

    IMPORTANT: This NEVER makes the strategy TRUSTED.
    The strategy enters CANDIDATE state and requires objective verification.
    
- `cognitive.record_experience`: Record an observable event in an ongoing experience episode (§24, §7).

    Accepts structured actions, observations, and state changes.
    Never sends raw unredacted private transcripts.
    
- `cognitive_record_experience`: Record an observable event in an ongoing experience episode (§24, §7).

    Accepts structured actions, observations, and state changes.
    Never sends raw unredacted private transcripts.
    
- `cognitive.refine_lattice_from_feedback`: Autonomously evolve higher-order invariants, tighten bounds, and discover cliques from execution feedback.
- `cognitive_refine_lattice_from_feedback`: Autonomously evolve higher-order invariants, tighten bounds, and discover cliques from execution feedback.
- `cognitive.report_transfer`: Record whether a transferred strategy helped or harmed on a novel task (§24, §19).
- `cognitive_report_transfer`: Record whether a transferred strategy helped or harmed on a novel task (§24, §19).
- `cognitive.resolve_intent`: Pragmatics: resolve indirect speech acts (e.g. ability questions to directives), anaphoric pronouns, and verify presuppositions.
- `cognitive_resolve_intent`: Pragmatics: resolve indirect speech acts (e.g. ability questions to directives), anaphoric pronouns, and verify presuppositions.
- `cognitive.run_closed_loop_agent`: Run the end-to-end cognitive agent closed loop (Perceive -> Model -> Decide -> Act -> Reflect -> Learn).
- `cognitive_run_closed_loop_agent`: Run the end-to-end cognitive agent closed loop (Perceive -> Model -> Decide -> Act -> Reflect -> Learn).
- `cognitive.run_multi_agent_simulation`: Simulate repeated multi-agent interaction with social dilemmas, speech acts, and reputation tracking.
- `cognitive_run_multi_agent_simulation`: Simulate repeated multi-agent interaction with social dilemmas, speech acts, and reputation tracking.
- `cognitive.safe_self_improve`: Safe self-improvement: propose modifications guarded by immutable verification oracles and anchor regressions.
- `cognitive_safe_self_improve`: Safe self-improvement: propose modifications guarded by immutable verification oracles and anchor regressions.
- `cognitive.simulate_actions`: Simulate and rank candidate actions by predicted feasibility, reward, and constraint safety.
- `cognitive_simulate_actions`: Simulate and rank candidate actions by predicted feasibility, reward, and constraint safety.
- `cognitive.solve_and_compare`: End-to-end autonomy: identify → guide → execute → baseline → verify → verdict.

    Give raw task data (scheduling: workers/shifts/eligibility/capacity/
    exclusivity; graph: nodes/edges; allocation: consumers/resources/...).
    Returns the guided solution, the unguided baseline, independent
    verification of both (with objective_source + independently_verified),
    and whether the engine improved the result.
    
- `cognitive_solve_and_compare`: End-to-end autonomy: identify → guide → execute → baseline → verify → verdict.

    Give raw task data (scheduling: workers/shifts/eligibility/capacity/
    exclusivity; graph: nodes/edges; allocation: consumers/resources/...).
    Returns the guided solution, the unguided baseline, independent
    verification of both (with objective_source + independently_verified),
    and whether the engine improved the result.
    
- `cognitive.solve_arithmetic`: Evaluate or simplify mathematical expressions (PEMDAS with power, functions like sqrt, exp, log, sin, cos).
- `cognitive_solve_arithmetic`: Evaluate or simplify mathematical expressions (PEMDAS with power, functions like sqrt, exp, log, sin, cos).
- `cognitive.solve_equation_system`: Solve linear equations (ax + b = c), quadratic equations (ax^2 + bx + c = 0), or linear systems (A x = b).
- `cognitive_solve_equation_system`: Solve linear equations (ax + b = c), quadratic equations (ax^2 + bx + c = 0), or linear systems (A x = b).
- `cognitive.solve_word_problem`: Solve math word problems (GSM8K/SVAMP/MATH) via topological constraint propagation.
- `cognitive_solve_word_problem`: Solve math word problems (GSM8K/SVAMP/MATH) via topological constraint propagation.
- `cognitive.start_experience`: Start an experience episode (§24, §10).

    Does not store raw prompts or full conversations. For long-horizon work,
    pass parent_experience_id (+ subgoal) to chain episodes with an inherited
    goal stack; unknown parents are rejected, never silently adopted.
    
- `cognitive_start_experience`: Start an experience episode (§24, §10).

    Does not store raw prompts or full conversations. For long-horizon work,
    pass parent_experience_id (+ subgoal) to chain episodes with an inherited
    goal stack; unknown parents are rejected, never silently adopted.
    
- `cognitive.step_simulated_environment`: Step an active simulated environment with an agent action.
- `cognitive_step_simulated_environment`: Step an active simulated environment with an agent action.
- `cognitive.submit_outcome`: Submit the structured outcome of an experience episode (§24, §10).

    Triggering this may induce candidate strategies in the engine.
    
- `cognitive_submit_outcome`: Submit the structured outcome of an experience episode (§24, §10).

    Triggering this may induce candidate strategies in the engine.
    
- `cognitive.synthesize_program`: Synthesize new algorithmic Python procedures on the fly with AST sandboxing and verification.
- `cognitive_synthesize_program`: Synthesize new algorithmic Python procedures on the fly with AST sandboxing and verification.
- `cognitive.synthesize_singular_path`: Synthesize an optimal, invariant-verified trajectory from initial state to goal through the singular bottleneck.
    
    Eliminates dead-end branching and hallucinated unfeasible solutions.
    
- `cognitive_synthesize_singular_path`: Synthesize an optimal, invariant-verified trajectory from initial state to goal through the singular bottleneck.
    
    Eliminates dead-end branching and hallucinated unfeasible solutions.
    
- `cognitive.theory_of_mind`: Theory of Mind: model agents' BDI mental states, test false beliefs (Sally-Anne), and infer goals via inverse planning.
- `cognitive_theory_of_mind`: Theory of Mind: model agents' BDI mental states, test false beliefs (Sally-Anne), and infer goals via inverse planning.
- `cognitive.tree_search`: Perform Monte Carlo Tree Search (UCT) over action sequences to find optimal trajectory.
- `cognitive_tree_search`: Perform Monte Carlo Tree Search (UCT) over action sequences to find optimal trajectory.
- `cognitive.verify_arithmetic_claim`: Formally verify an arithmetic equality claim, audit numerical stability, condition number, and cancellation risks.
- `cognitive_verify_arithmetic_claim`: Formally verify an arithmetic equality claim, audit numerical stability, condition number, and cancellation risks.
- `cognitive.verify_ethics_and_norms`: Normative ethics & fairness: enforce deontological vetos, evaluate Rawlsian vs Utilitarian welfare, and arbitrate moral dilemmas.
- `cognitive_verify_ethics_and_norms`: Normative ethics & fairness: enforce deontological vetos, evaluate Rawlsian vs Utilitarian welfare, and arbitrate moral dilemmas.
- `cognitive.verify_lattice_transition`: Verify a candidate state or transition S_t -> S_{t+1} against invariant boundary manifolds.
- `cognitive_verify_lattice_transition`: Verify a candidate state or transition S_t -> S_{t+1} against invariant boundary manifolds.
- `cognitive.verify_strategy`: Run objective deterministic verification on a strategy (§24, §16).

    Clients cannot self-promote. Verification is evaluated server-side.
    Pass task_structure_id (from cognitive.identify_task) so constraints are
    independently recomputed from registered descriptors instead of trusting
    trace flags. Objective precedence: explicit caller value → recomputed from
    raw data → registered spec (labeled unknown) → nested trace claims ONLY
    when trust_trace_objective=true → otherwise unknown, never silent 0.0.
    Returns passed/score plus details.objective_source and
    details.independently_verified so callers know what was recomputed
    versus taken on trace claims. Failures are structured, never bare.
    
- `cognitive_verify_strategy`: Run objective deterministic verification on a strategy (§24, §16).

    Clients cannot self-promote. Verification is evaluated server-side.
    Pass task_structure_id (from cognitive.identify_task) so constraints are
    independently recomputed from registered descriptors instead of trusting
    trace flags. Objective precedence: explicit caller value → recomputed from
    raw data → registered spec (labeled unknown) → nested trace claims ONLY
    when trust_trace_objective=true → otherwise unknown, never silent 0.0.
    Returns passed/score plus details.objective_source and
    details.independently_verified so callers know what was recomputed
    versus taken on trace claims. Failures are structured, never bare.