> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sensecode.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Non-Goals

> What Sense should never become, and the one test that decides it.

## The test

<Note>
  If Sense can be replaced by `Python + SDK + framework` without losing
  fundamental capabilities, its language-level abstraction is not strong
  enough.
</Note>

Every feature added to Sense should be able to answer: *what does this make
impossible, or at least much harder, to do by accident in a plain library?*
`Answer` passes — a library can't stop you from treating an AI answer as a
fact, but the type system can. `Action`'s prepare→verify→commit passes — a
library can't stop a decorated function from also just running immediately
if someone doesn't call it the "right" way; the interpreter can refuse to
run it any other way. A feature that's just a convenience wrapper around
what a library already does cleanly should probably *be* a library, not a
language feature.

## What Sense explicitly refuses to become

<AccordionGroup>
  <Accordion title="Python with an agent keyword">
    Bolting `agent`/`Answer`/`action` onto Python's existing semantics
    (mutable-everything, no capability model, no distinction between a pure
    function and a side-effecting one) doesn't get you Sense's guarantees —
    it gets you Python with extra vocabulary that nothing enforces.
  </Accordion>

  <Accordion title="An LLM SDK">
    An SDK's job is to make one vendor's API pleasant to call. Sense's
    `ask(...)` deliberately never exposes which model, vendor, or even
    whether an LLM was involved at all — that's a runtime routing decision,
    the same way `sort()` doesn't expose which algorithm ran.
  </Accordion>

  <Accordion title="Another LangChain-style framework">
    Frameworks compose existing primitives from an *underlying* language
    that doesn't understand them. Sense's bet is that some of those
    primitives (uncertainty, staged effects, capability scoping) belong at
    the language level instead, where they can actually be enforced rather
    than merely offered.
  </Accordion>

  <Accordion title="A prompt-templating language">
    Sense is not primarily about generating good prompts. `ask(prompt)`
    takes a plain string; prompt engineering is orthogonal to what Sense is
    trying to solve.
  </Accordion>

  <Accordion title="A workflow engine with AI sprinkled in">
    Workflow engines orchestrate steps a human already fully specified.
    Sense's eventual "the *runtime* constructs a plan under real
    constraints" idea (not yet built — see the
    [computational model](/philosophy/computational-model)) is a different
    problem than sequencing pre-defined steps.
  </Accordion>

  <Accordion title="A chatbot scripting language">
    Sense has no special affinity for conversational UIs. `ask(...)` is
    a general reasoning primitive usable anywhere a value is needed, not a
    dialogue-management construct.
  </Accordion>

  <Accordion title="A DSL that only orchestrates APIs">
    If every Sense construct just maps 1:1 onto an existing REST call with
    extra syntax, the language isn't adding anything an OpenAPI client
    generator couldn't. Sense's constructs (`Answer`, `Action` states,
    scoped `policy`) don't correspond to any single API shape — they're
    runtime concepts the interpreter itself understands and enforces.
  </Accordion>

  <Accordion title="A language where every operation secretly invokes an LLM">
    Sense's deterministic core (arithmetic, control flow, arrays, functions)
    runs with zero network access and zero AI involvement, by design — see
    [Values & Types](/language/values-and-types). AI is an opt-in
    capability layered on top, never an ambient, invisible dependency of
    ordinary code. A Sense program with no `ask`/`model`/`agent` in it
    is exactly as offline and deterministic as an equivalent Python script.
  </Accordion>
</AccordionGroup>

## Continue

<CardGroup cols={2}>
  <Card title="Design order" icon="list-ol" href="/philosophy/design-order">
    Why syntax came after semantics were settled.
  </Card>

  <Card title="Comparison" icon="scale-balanced" href="/comparison">
    Sense against Python and other languages, feature by feature.
  </Card>
</CardGroup>