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

# install_runtime

> Install the Python runtime and optionally bind your harness in one call.

Use `vx.install_runtime(...)` for the one-call raw Python path.

It does two things:

1. Installs the Python runtime capture layer
2. If you pass a target object, binds your named methods as VerifiedX surfaces in the same call

## Basic usage

```python theme={null}
from verifiedx import init_verifiedx

vx = init_verifiedx()

vx.install_runtime(
    node,
    llm={"call_model": "gpt-5.4-mini"},
    retrievals={"lookup_internal_workflow": "internal workflow evidence"},
    actions={"set_workflow_status": "set_workflow_status"},
    memories={"remember_customer_preference": "remember_customer_preference"},
)
```

<Note>
  This is the simplest raw Python integration. You keep your existing harness and declare which methods should be treated as LLM calls, retrievals, protected actions, or durable memory writes.
</Note>

## Install now, bind later

If you want to install runtime capture first and bind a harness later, call `install_runtime()` with no target:

```python theme={null}
vx.install_runtime()
vx.bind_harness(node, ...)
```

## Parameters

<ParamField path="node" type="object">
  Optional target object to bind in place. If provided, VerifiedX wraps the named methods on that object during the same call.
</ParamField>

<ParamField path="llm" type="dict">
  Optional LLM method bindings.

  You can use either:

  * string shorthand: `{"call_model": "gpt-5.4-mini"}`
  * object form: `{"call_model": {"model_name": "gpt-5.4-mini"}}`
</ParamField>

<ParamField path="retrievals" type="dict">
  Optional retrieval bindings for reads and lookups that should contribute decision context.

  You can use:

  * string shorthand: `{"lookup_internal_workflow": "internal workflow evidence"}`
  * tuple shorthand: `{"search_public_web": ("public web context", "external_retrieval")}`
  * object form with `query` and optional `object_type`
</ParamField>

<ParamField path="actions" type="dict">
  Optional high-impact business method bindings such as record mutations, workflow updates, or message sends.

  You can use either:

  * string shorthand: `{"set_workflow_status": "set_workflow_status"}`
  * object form: `{"set_workflow_status": {"tool_name": "set_workflow_status"}}`
</ParamField>

<ParamField path="memories" type="dict">
  Optional durable memory-write bindings.

  You can use either:

  * string shorthand: `{"remember_customer_preference": "remember_customer_preference"}`
  * object form: `{"remember_customer_preference": {"tool_name": "remember_customer_preference"}}`
</ParamField>

<ParamField path="tools" type="dict">
  Optional general tool bindings for helper methods and tool history.

  If a method is definitely a durable memory write or another high-impact effect, prefer `memories` or `actions`.
</ParamField>

## What it enables

`install_runtime(...)` turns on the Python runtime lane and lower-seam capture automatically.

That means you get runtime visibility for real side effects even before you bind every business method manually. Explicit bindings are how you promote your own harness methods into named VerifiedX surfaces with cleaner receipts and better business-level boundaries.

## Return value

Returns an activation report for the installed Python runtime.

Most builders do not need to use the return value directly.

## Example

```python theme={null}
from verifiedx import init_verifiedx

class WorkflowNode:
    def call_model(self, messages):
        ...

    def lookup_internal_workflow(self, workflow_id):
        ...

    def set_workflow_status(self, workflow_id, status):
        ...

    def remember_customer_preference(self, customer_id, preference):
        ...

vx = init_verifiedx()
node = WorkflowNode()

vx.install_runtime(
    node,
    llm={"call_model": "gpt-5.4-mini"},
    retrievals={"lookup_internal_workflow": "internal workflow evidence"},
    actions={"set_workflow_status": "set_workflow_status"},
    memories={"remember_customer_preference": "remember_customer_preference"},
)
```

In this example, VerifiedX will:

* observe `call_model` as an LLM call
* record `lookup_internal_workflow` as retrieval context
* protect `set_workflow_status` as a high-impact boundary
* protect `remember_customer_preference` as a durable memory write