Several rooms, explicit shared worlds

Prerequisites: room setup and a free-threaded Python runtime. The concurrency example opens a private room for each worker and points the rooms at one shared target world. Each room owns its workstation and memory subscriptions.

Check results across the boundary

Generated code places its answer in result; the execution payload carries that answer alongside acceptance and error information. Expert 21 starts with a single sum, then launches four coordinated workers and checks the exact results: 5050, 9, "0-1-4-9-16", and 5040.

It also checks that the workstations have distinct identities. This demonstrates private working spaces with a shared runtime target. It is not a timing benchmark and does not establish a universal absence of contention.

Match coordination to the operation

Computing an answer and changing topology have different coordination needs. Continue to the admission and gate guide for structural changes and shutdown. Use multiple-world targeting when workers should operate on different runtime worlds rather than a shared one.

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:
    # THE SHARED WORLD. One frame, postured for codegen (expert 11).
    book = md.Spellbook(aetheric_frame=FRAME)
    book.bind(spell=Meter, existence="unique", binding_name="factory-meter")
    book.configure_aether_frame(
        system_state="dynamic",
        disposal=None,
        disposal_method_names=None,
        rift_enabled=True,
        ai_native=True,
    )
    book.conjure(name="factory-root")

    nexus = md.Nexus()
    system_configuration = nexus.create_configuration()
    system_configuration.with_rift_creation_enabled(True)
    system_configuration.with_allowed_target_frame_names([FRAME])
    system_configuration.with_multiple_target_frames(True)
    system_configuration.with_max_target_frame_count(4)
    nexus.activate(system_configuration)
    print("one shared world:", FRAME)

    # ONE AGENT FIRST, SLOWLY, SO THE PAYLOAD IS VISIBLE.
    solo = _open_room(nexus, "solo")
    verdict = solo.command_system.validate_codegen(
        JOBS["adder"], frame_name=FRAME,
    )
    print()
    print("validate ->", verdict)
    assert verdict["accepted"] is True

    payload = solo.command_system.execute_codegen(
        JOBS["adder"], frame_name=FRAME,
    )
    print("execute  -> keys:", sorted(payload))
    assert payload["accepted"] is True
    assert payload["frame_name"] == FRAME
    assert payload["result"] == 5050
    print("execute  -> result:", payload["result"])
    print("  the code set `result`; the executor lifted THAT ONE NAME out")
    print("  everything else it computed died with the sandbox")

    # NOW FOUR AGENTS AT ONCE, EACH IN ITS OWN ROOM.
    rooms = {}
    outcomes = {}
    errors = []
    guard = threading.Lock()
    ready = threading.Barrier(len(JOBS))

    def run_agent(agent_name: str) -> None:
        try:
            room = _open_room(nexus, agent_name)
            with guard:
                rooms[agent_name] = room
            # Line them up so the executions genuinely overlap.
            ready.wait(timeout=10)
            result = room.command_system.execute_codegen(
                JOBS[agent_name], frame_name=FRAME,
            )
            with guard:
                outcomes[agent_name] = result
        except Exception as error:  # noqa: BLE001 - reported, not swallowed
            with guard:
                errors.append((agent_name, repr(error)))

    threads = [
        threading.Thread(target=run_agent, args=(name,), name=f"agent-{name}")
        for name in JOBS
    ]
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join(timeout=30)

    assert not errors, f"agent failures: {errors}"
    assert len(outcomes) == len(JOBS)
    print()
    print("four agents ran their own code concurrently:")
    for agent_name in sorted(outcomes):
        result = outcomes[agent_name]
        assert result["accepted"] is True
        assert result["result"] == EXPECTED[agent_name]
        print(f"   {agent_name:<8} -> {result['result']!r}")
    print("  none of them waited on another - computing a value is not")
    print("  a structural change, so there was nothing to serialize")

    # PRIVATE BENCHES. Four rooms, four workstations, four ids.
    workstation_ids = {name: room.workstation.workstation_id
                       for name, room in rooms.items()}
    assert len(set(workstation_ids.values())) == len(rooms)
    print()
    print("four rooms ->", len(set(workstation_ids.values())),
          "distinct workstations")
    print("  private bench each, one shared world - that is the isolation")

    # AND A ROOM'S MEMORY IS ITS OWN. Subscribe on one; run on two.
    watcher = rooms[sorted(rooms)[0]]
    other = rooms[sorted(rooms)[1]]
    seen = []
    subscription = watcher.memory_system.register_memory_callback(seen.append)
    assert watcher.memory_system.memory_enabled is True

    watcher.command_system.execute_codegen(JOBS["adder"], frame_name=FRAME)
    other.command_system.execute_codegen(JOBS["adder"], frame_name=FRAME)

    print()
    print("subscribed to ONE room, then ran in two:")
    print("   records captured:", len(seen))
    print("  the other room's identical call is absent - per-agent audit")
    print("  falls out of per-agent rooms, nobody had to build it")
    watcher.memory_system.unregister_memory_callback(subscription)

    print()
    print("four agents, four benches, one world, no ceremony")
    print("`result` is the whole boundary: one value out, nothing leaks")

Runnable examples

Many agents writing code at once — Expert 21
One workshop many worlds — Expert 13
The gate that waits for readers — Expert 35

All expert examples · Level contents · Full contents

Canonical page source