Connect

8 clients · secrets stay placeholders

JSON (mcpServers)Claude CodeCodexOpenCodeCursorVS CodeGemini CLIGoose

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

claude mcp add --transport http neotic https://www.neotic.app/api/mcp

[mcp_servers.neotic]
url = "https://www.neotic.app/api/mcp"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "neotic": {
      "type": "remote",
      "url": "https://www.neotic.app/api/mcp",
      "enabled": true
    }
  }
}

{
  "mcpServers": {
    "neotic": {
      "type": "http",
      "url": "https://www.neotic.app/api/mcp"
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=neotic&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vd3d3Lm5lb3RpYy5hcHAvYXBpL21jcCJ9"
}

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

{
  "mcpServers": {
    "neotic": {
      "httpUrl": "https://www.neotic.app/api/mcp"
    }
  }
}

extensions:
  "neotic":
    enabled: true
    name: "neotic"
    type: streamable_http
    uri: "https://www.neotic.app/api/mcp"
    timeout: 300

Quality 74 / 100needs work

protocol88 · weight 25

pass
protocol.modernsupports 2026-07-28 (server/discover)
pass
protocol.statelessanswers without a session
pass
protocol.transportstreamable HTTP
warn
protocol.list_ttltools/list declares ttlMs 0, so clients re-fetch it on every use

authorizationn/a · weight 15

n/a
auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
n/a
auth.secret_in_urlno templated URL

tool hygiene50 · weight 30

pass
tools.descriptionsevery tool has a description
warn
tools.description_length2 tools have descriptions over 1,024 characters, which crowds the context
pass
tools.schemasevery tool has an object input schema
fail
tools.annotationsno tool declares readOnlyHint or destructiveHint, so clients cannot tell safe calls from risky ones
fail
tools.directory_hintsno 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_costabout 25,450 tokens to load every tool, a large share of an agent's context
pass
tools.api_dumptools are not a one-to-one API dump

stability100 · weight 15

pass
stability.changesno tool changes in 30 days
pass
stability.rug_pullno tool changed its meaning under the same name

dependenciesn/a · weight 15

n/a
deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

140 tools, about 25,450 tokens to load them all · tool set b507b8f1fa39 · checked 2026-10-19 10:52 UTC

Tool changes

No tool definition changes recorded. A server's first observation is its baseline; later probes record what changes.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 50 / 100

no-repositoryunreachable

provenance55

liveness0

freshness85

hygiene80

+dns-namespace +website -unreachable(7 failures) ~updated-58d-ago -no-repository

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remote	auth	reachable	uptime 30d	p50	protocol	last ok
`https://www.neotic.app/api/mcp` streamable-http	none	no (7 failures)	86%	406 ms	2026-07-28	2026-10-05

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.

Schemas: list_tools.

Similar MCP servers

Official server.json

{
  "name": "app.neotic.www/neotic",
  "title": "Neotic",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://www.neotic.app/api/mcp",
      "type": "streamable-http"
    }
  ],
  "version": "1.0.0",
  "websiteUrl": "https://www.neotic.app",
  "description": "AI agents create contextual in-app experiences, announcements, and triggers with Neotic."
}