A language for
AI
workflows.

Sense has its own syntax, parser, and interpreter, so it is a domain-specific language. The interpreter is written in Python and can call installed Python libraries. That describes the implementation; the practical reason to try it is whether its workflow structure helps you.

You can build the same kind of workflow in Python. Sense puts models, tools, policies, and action stages into a consistent language structure. It is worth exploring if that makes your code easier to read and change. It does not claim to be faster or to replace Python’s ecosystem.

You can build agents with LangChain, LangGraph, or Deep Agents. Sense offers another way: write model calls, memory, and permissions directly in your code.

For example: save a value, check its history, allow a search, or require approval before sending an email.

AI can write the code and choose the steps. You still decide what your application can do.

Why try Sense? To see whether these built-in features make your code simpler to write, read, and maintain.

No. You still choose tools, write instructions, configure models, and define execution rules. Sense provides a way to express that program. It does not make a model more capable or guarantee that it achieves the goal.

Generated code still needs review, maintenance, and debugging. Sense aims to make the workflow rules easier to see. That only helps if you find the resulting code clearer; AI code generation alone is not a reason to adopt another language.

No rewrite is needed to try an isolated Sense script. It can call installed Python modules through Python interop. Existing Python code does not automatically become Sense code, and compatibility with a library or framework needs checking. Start with one small workflow.

Sense also has functions, variables, conditions, loops, imports, and return values. Use local when you need a new local binding rather than updating an existing outer one. return produces a result; returns annotates a result type on constructs such as tools. Start with ordinary code and add memory, policies, or agents when your program needs them. See the full keyword reference.

• Function: runs a piece of code when you call it. Example: calculate a total. Pro: simple and reusable. Con: no built-in capability check or pause/resume lifecycle.
• Agent: runs a task when started and keeps its own state. Example: investigate a report and pause for input. Pro: you can track its status and resume paused work. Con: you must manage its lifecycle; declaring an agent does not make it intelligent.
• Tool: a callable operation that can be offered to a model, with a description and optional required permission. Example: look up an order. Pro: reusable access with capability checks when declared. Con: it runs when called; there is no separate commit step.
• Action: prepares an operation whose body runs later, on commit. Example: prepare an email before sending. Pro: a clear point for permission checks and optional approval. Con: more execution steps, and recovery code is still your responsibility.

Start with a function. Use a tool for model-callable work or capability checks, an action when execution needs a separate commit, and an agent when you need task state and pause/resume.

model declares a model value. set delegation selects the model for the current scope, and ask(...) uses that selection. The returned Answer has a value, source, and confidence field. OpenAI and Anthropic are supported today, and more provider integrations are planned. Their confidence is currently nil, meaning unknown. An Answer is not proof that the response is correct.

No. An agent runs the code you put in its body. It can use ordinary functions, memory, tools, and model calls as needed. Use a model when the task needs it; the agent keyword itself does not call a model or decide what to do.

A session runs a block in a child scope, letting you choose a model or policy for that work without changing the outer setting. An agent has identity, execution state, and a start/pause/resume lifecycle. Use a session to scope work and an agent when that lifecycle is useful. Neither means crash recovery is automatic.

Yes. Your code can call a tool directly. Its declared capability is checked and its body runs if permitted. Offering it through ask_with_tools(...) additionally lets the model request it. A tool is not limited to model-selected calls.

A skill(...) groups related tools under a name and description. For example, bundle order lookup and shipment tracking tools for reuse. Pro: pass one bundle instead of repeating the same tool list. Con: it is another grouping to maintain and does not write the tools for you. A skill is a value created by a function, not a separate agent.

memory holds key/value information in the running process. persistent memory saves supported values in a SQLite-backed store across runs and records changes as versions. Use working memory for temporary notes and persistent memory when later runs need the information. This is data storage, not automatic model learning.

remember(key, value) stores a value; recall(key) reads the latest one. Persistent memory also provides history(key) to list changes and as_of(key, version) to read an earlier value. For example, inspect when a stored status changed from draft to reviewed. These are methods on memory, not separate reserved keywords.

For ordinary memory, forget(key) removes the current entry. For persistent memory, it records a removal while retaining earlier versions. Recall then returns nil, but history remains available. Do not use forget as a promise to erase sensitive data from storage.

No. Declaring memory stores data; it does not automatically add it to every prompt. Use ask_with_memory(...) when you want stored context included in a model request. Choose what you store and share; persistent data can still be outdated or incorrect.

requires names a capability on an operation, such as web.search. A policy block uses allow or deny to set its permission. The runtime checks that declared capability when the operation is used. Action verification and commit each check permissions. These rules do not inspect whether the content of an operation is a good decision.

Rules are scoped. The nearest matching rule is used, and an inner scope can override an outer rule. A capability without a matching rule defaults to allow. Policies govern declared capabilities; they are not an operating-system sandbox or an automatic block on all Python side effects.

No. Use requires approval when the action needs approval before commit. Without that requirement, an action still has preparation, verification, and commit steps, but does not automatically ask a person. You must connect the approval step to the appropriate person or application process.

No. You write the recovery logic for operations that support it. Compensation can fail and may not fully undo an external effect. Sending a correction does not unsend an email. Sense does not generate an undo operation for you.

async enables concurrent agent or tool work; it does not automatically make shared application state safe. requires approval adds an approval requirement before an action can commit. import python connects installed Python functionality. These features serve different purposes: concurrency, an execution gate, and integration.

Sense currently integrates OpenAI and Anthropic, with more LLM provider integrations planned. Select one with inference("openai", ...) or inference("anthropic", ...). Each needs its provider package, an API key, and an internet connection. Check the documentation for the latest supported providers as integrations are added.

For OpenAI, install pip install "sense-lang[openai]" and set OPENAI_API_KEY. For Anthropic, install pip install "sense-lang[anthropic]" and set ANTHROPIC_API_KEY. Choose a model available to your provider account. Installing Sense alone does not include provider access or API credits.

No. The mock provider returns configured demo responses; it does not run an LLM or perform local inference. Real model responses use an integrated provider. OpenAI and Anthropic are supported today, with more integrations planned. Ordinary code, memory operations, and local examples can run without calling a model.

Sense is in early development. Evaluate it on small, low-risk workflows first. Its capability checks are not a sandbox for arbitrary Python code, and pausing an agent is not a promise of recovery after a process crash. Review the implementation and limitations before depending on it.