Stand up an agent-run Lab on Molecule: an AI owner, with Claude, Codex and Grok joined as contributors through Agent Connect

Molecule Labs gives a research project an onchain identity (a LabNFT with its own account) and a data room. Agent Connect lets an outside AI agent join a Lab: the Lab's owner approves the connection, and the agent gets its own wallet and a role on the Lab. Starting from the public docs alone, set up one Lab on Molecule production (Base mainnet) that is run by agents: an AI agent owns it, and three further AI agents, one each from Claude, Codex and Grok, are joined to it as Contributors through Agent Connect, upload a file each and read each other's files. Report where the docs did not work as written and where a human had to step in. The Lab and the agents' roles are checked against Base; the connections and the file work are decided from the recorded tool results in the Submission. Among valid Submissions, the one submitted first wins.

The run

Everything happens on Molecule production, on Base (chain id 8453). The run has three steps:

1. Lab. Mint a LabNFT to the Solver address and register the Lab so that it has a data room, in any way the docs describe.
2. Contributors. Connect three AI agents to the Lab through Agent Connect at https://mcp.molecule.xyz, each with the Contributor role: one from a Claude app (claude.ai or Claude Code), one from Codex and one from Grok. The Lab's owner, the Solver address, approves each connection as the docs describe. To Agent Connect each app is its own agent with its own wallet, so the three agents have three different wallets.
3. Work. Each agent uploads one file to the Lab with the data_room_upload tool, and then reads one other agent's file with the data_room_read tool:

Each uploaded file holds the text written by followed by the uploading agent's wallet address in lowercase, starting with 0x and with all 40 hex digits. No real research data, no personal data and nothing confidential goes into the Lab. Molecule production is public and permanent: the Lab and its files' history stay.

The Solver address is the account that makes the Submission on ElgoraHub. The same address, on Base, receives the LabNFT and is the Lab's owner.

The aim is a Lab in which every step is done by AI agents, including the owner's approval of each connection. Whether a human helped is not part of acceptance; it is reported, step by step, in friction.md.

What decides that the run happened

Two kinds of evidence decide acceptance, and nothing else does:

• Onchain evidence, submitted as files. The Submission holds the mint transaction's receipt and, for one Base block the Solver chooses (the check block), the Lab's owner and each agent wallet's role as read from Base at that block. These submitted values decide the onchain conditions. Base, a public source named under Inputs, is the authority they are compared with: a submitted value that differs from Base at the stated transaction or block is incorrect. A connection made through Agent Connect leaves the agent's wallet with the Contributor role and the agent flag set.
• The recorded tool results in run.json: for each of the three agents, the result of agent_connect_whoami, of its data_room_upload call and of its data_room_read call, as the Agent Connect server returned them. The Lab's data room is not publicly readable, so whether the agents were connected through Agent Connect and whether the files were stored and read is decided from these records and their agreement with the onchain evidence. The stored files are not read back, and the order in which the tool calls were made is not part of acceptance.

What the friction log is

friction.md is the second thing this bounty buys. For each of the three steps it says whether the instructions in the docs worked as written and whether the step was done without a human. Where the docs did not work, it names the docs page, quotes the instruction, says what happened instead and says what worked. Where a human stepped in, it says what the human did.

Result meaning

A valid Submission shows that a Lab owned by the Solver address has three agent wallets holding the Contributor role with the agent flag, that the recorded connections are from a Claude app, Codex and Grok, and that the recorded tool results show each agent reading a file another agent uploaded. It does not show that no human took part, and it does not show that the path works every time. The recorded tool results and friction.md are the Solver's own record.

run.json fields:

• solver_address: the Solver address, 0x followed by 40 hex digits.
• mint_tx_hash: hash of the Base transaction that minted the LabNFT.
• token_id: the LabNFT token id minted, as a decimal string.
• ocl_id: the Lab's oclId, 0x followed by 64 hex digits.
• lab_account: the Lab's account address created by the mint.
• check_block: the number of the check block, a decimal string.
• owner_at_check_block: the address ownerOf(uint256) on the LabNFT contract returns for token_id at the check block.
• agents: an object with exactly the three keys claude, codex and grok. Each value has:

• agent_wallet: the agent's wallet address;
• role_at_check_block: an object with role, expiry and is_agent, the three values getRole on the AccessResolver returns for ocl_id and this wallet at the check block;
• whoami: the JSON result of that agent's agent_connect_whoami call, made after it was connected to the Lab;
• upload: an object with arguments (the arguments of that agent's data_room_upload call) and result (what the tool returned);
• read: an object with arguments (the arguments of that agent's data_room_read call) and result (what the tool returned).

friction.md has one section per step, headed ## Step 1 to ## Step 3. Each section starts with these two lines, each ending in yes or no: Worked as written: and Done without a human:. A section with Worked as written: no holds one or more entries, each with the docs page path or URL, a quote of the instruction, what happened instead, and what worked. A section with Done without a human: no says what the human did.

Contracts on Base used by the acceptance criteria:

The AccessResolver function used is getRole(bytes32 oclId, address account) returns (uint8 role, uint64 expiry, bool isAgent), where role 2 is Contributor. On 12 November 2026 the Poster read the role of an agent wallet that had been connected to a Lab through Agent Connect from Claude Code: the call returned role 2 and isAgent true, and that agent's agent_connect_whoami result was a JSON object with host equal to claude-code, an agentWallet, and a grants array whose entries hold oclId, role, status and a lab object with name and shortname. The Poster has not observed the host value of a Codex or a Grok connection; the host rule in the acceptance criteria is written to hold for any value that names the app.

• Valid Submissions are those meeting every acceptance criterion.
• Among valid Submissions, the active Submission with the lowest submission_call_count wins. submission_call_count is ElgoraHub's bounty-wide count of accepted submissions at that call; it rises with every call, so no two Submissions share one, and resubmitting replaces the active Submission and gives it a later count.
• If none is valid, the outcome is no_valid_submission.

• Real research data, personal data or anything confidential in any file.
• Security testing of Agent Connect, the API or the contracts.
• Granting a role by calling the AccessResolver directly instead of connecting through Agent Connect.
• Tokenization and payments.