Give each agent an explicit room and target

Prerequisites: Nexus setup and world posture. A Rift owns one room, including its viewer, workstation, command surface, and optional codegen machinery.

Room	Main purpose
`static`	Inspect the permitted live surface
`capability`	Use the broader runtime command surface and research reads
`codegen`	Add source validation/execution/materialization and research authoring operations

Ask list_supported_command_methods() for the commands the actual room exposes. A method may also require an active subsystem. Availability and authority are different: activating research does not add its authoring commands to a capability room.

Attach with both sides configured

The target frame must opt into observation before conjure. Nexus policy must allow the target. Conjure publishes the world, then the Rift attaches with create_frame_link(frame_name). Codegen targets also require dynamic and AI-native posture. The target-attachment lesson exercises refusals from both sides.

For multiple worlds, configure the allowed names, permit multiple targets, and set the target count. Attach each world explicitly. A shared observer leaves the underlying worlds isolated.

Hold objects deliberately

The workstation holds named handles; the command system resolves permitted world access. A bound object retains its ordinary Python behavior. Post-bind use of an already-granted handle is a different boundary from acquiring it. See workstation ownership and the complete workbench lesson.

Room policy and code validation are application controls. They are not an operating system sandbox or a proof that arbitrary hostile Python is safely isolated.

The workflow in code

These are the core steps from the saved example. Use its complete linked script for all class definitions and setup.

def main() -> None:
    # A frame that never opted in. This is the default, on purpose.
    closed = md.Spellbook(aetheric_frame="closed-world")
    closed.bind(spell=Ledger, existence="unique", binding_name="closed-world")
    closed.conjure(name="closed-root")

    # ...and three that did. 'unlisted' is postured EXACTLY like
    # 'observable' - the only thing that will differ is the Nexus's own
    # policy, which is how we isolate gate A from gate B.
    _postured_frame("observable")
    _postured_frame("unlisted")
    _postured_frame("workshop", dynamic=True)
    print("four frames: one default, two rift-enabled, one AI-native")

    # The Rift domain has to be live before any of this matters - and the
    # NEXUS has to be told which worlds it may reach. The shipped
    # allow-list is ("default",), so every frame here is foreign to it.
    nexus = md.Nexus()
    system_configuration = nexus.create_configuration()
    system_configuration.with_rift_creation_enabled(True)
    system_configuration.with_allowed_target_frame_names(
        ["observable", "workshop", "closed-world"],
    )
    # Two worlds get attached below, and the budget is NEXUS-WIDE.
    system_configuration.with_multiple_target_frames(True)
    system_configuration.with_max_target_frame_count(4)
    nexus.activate(system_configuration)
    assert nexus.is_activated is True
    print("nexus activated; allow-list names 3 of the 4 worlds")

    # A capability room, then ATTACH it to the world that opted in AND is
    # named by the observer's policy. Both parties agreed.
    rift_configuration = nexus.create_rift_configuration()
    rift_configuration.with_space_type("capability")
    rift = nexus.create_rift(configuration=rift_configuration,
                             rift_name="observer")
    rift.mark_active()
    rift.create_frame_link("observable")
    print()
    print("attached: a capability rift now targets 'observable'")

    # GATE A - THE OBSERVER SAID NO. 'unlisted' is postured identically to
    # 'observable'; the only difference is that the Nexus never named it.
    # The frame's consent is irrelevant here, and note WHICH gate answers:
    # policy is checked BEFORE posture is ever consulted.
    try:
        rift.create_frame_link("unlisted")
        raise AssertionError("expected a refusal: not on the allow-list")
    except ValueError as error:
        assert "not allowed by Nexus policy" in str(error)
        print("refused 'unlisted' -", error)
        print("  same posture as 'observable' - the OBSERVER refused it")

    # GATE B - THE WORLD SAID NO. 'closed-world' IS on the allow-list, so
    # policy passes and the posture gate answers instead. Opposite party,
    # opposite reason, and the message names which.
    try:
        rift.create_frame_link("closed-world")
        raise AssertionError("expected a refusal: rift_enabled is False")
    except ValueError as error:
        assert "rift_enabled" in str(error)
        print("refused 'closed-world' -", error)
        print("  allow-listed, but never opted in - the WORLD refused it")

    # A CODEGEN room raises the bar twice more: ai_native AND dynamic.
    codegen_configuration = nexus.create_rift_configuration()
    codegen_configuration.with_space_type("codegen")
    codegen_rift = nexus.create_rift(configuration=codegen_configuration,
                                     rift_name="maker")
    codegen_rift.mark_active()

    # 'observable' is rift-enabled but NOT ai-native, so codegen refuses it
    # while capability accepted it. Same frame, different room, different
    # answer - the posture is read against what the room can DO.
    try:
        codegen_rift.create_frame_link("observable")
        raise AssertionError("expected a refusal: codegen needs ai_native")
    except ValueError as error:
        print()
        print("codegen refused 'observable' -", error)

    codegen_rift.create_frame_link("workshop")
    print("codegen attached to 'workshop', which is dynamic AND ai-native")

    # THE BUDGET IS NEXUS-WIDE, NOT PER RIFT. Two rifts, two different
    # worlds, and they spent TWO of max_target_frame_count between them -
    # which is why this lesson had to raise the cap from its default of 1
    # even though no single rift targets more than one world.
    print()
    print("two rifts hold two target frames; the cap is shared, not")
    print("per-rift - target frames are ref-counted across the Nexus")

    print()
    print("attachment is the authority boundary - checked once, there")
    print("a frame is observable because IT said so, before it settled")
    print("and reachable because the OBSERVER said so - both, or neither")

Runnable examples

Pointing a rift at your own frame — Expert 11
Research is graduated by room — Expert 08
One workshop many worlds — Expert 13
The workstation an agents workbench — Expert 20

All expert examples · Level contents · Full contents

Canonical page source