Functions

Declare one

def square(x):
    return x * x

def add(a: Int, b: Int) -> Int:
    return a + b

Parameters and the return type are both optional and independently typed. Same shape as Python: def leading, -> for the return type.

A plain function has no permission check and no audit entry — it’s not the right tool the moment a call needs one. See Which keyword do I want?

Inline bodies

Short bodies can skip the indented block:

def classify(n) -> String:
    if n < 0: return "negative"
    if n == 0: return "zero"
    return "positive"

Closures

A function closes over the scope it was declared in:

base = 10
def add_base(x: Int) -> Int:
    return x + base
print(add_base(5))   # 15

Assignment follows the one assignment rule: a function body can mutate a variable from its enclosing scope directly, no nonlocal needed:

total = 0
def accumulate(x: Int):
    total = total + x   # mutates the outer total
accumulate(3)
accumulate(4)
print(total)   # 7

Docstrings

A bare string as the first statement of a function’s body is captured as its .doc, same as Python:

def square(x: Int) -> Int:
    """
    Returns the square of x.
    """
    return x * x

"""...""" and "..." both work — plain "..." already tolerates an embedded newline. The text is dedented and trimmed for you. No docstring? .doc is nil, never an error. tool, action, and agent bodies work the same way; see them in sense inspect’s panels.

Type checking

Checked at the call site and at return:

def f(a: Int) -> Int:
    return a
f("nope")   # SenseTypeError at the call site

def g() -> Int:
    return "not an int"   # SenseTypeError when the function returns

Real, but shallow (matches_type() — see Values & Types), not full static inference.

Arity is strict

Every parameter is required, exactly once, no defaults:

def add(a: Int, b: Int) -> Int:
    return a + b
add(1)          # error: 'add' expects 2 argument(s), got 1
add(1, 2, 3)    # error: 'add' expects 2 argument(s), got 3

(Some builtins — print, range — are variadic. User-defined functions aren’t, yet.)

Continue

Control flow

if/else, while, for, break, continue.

Actions

Looks like a function, behaves completely differently — for anything that changes the outside world.

Language

AI-Native

Safety

Declare one

Inline bodies

Closures

Docstrings

Type checking

Arity is strict

Continue

Control flow

Actions

​Declare one

​Inline bodies

​Closures

​Docstrings

​Type checking

​Arity is strict

​Continue

Control flow

Actions

Declare one

Inline bodies

Closures

Docstrings

Type checking

Arity is strict

Continue