# Cancel a reply Source: https://docs.biomni.phylo.bio/api-reference/pages/cancel-reply api-reference/openapi.json POST /experimental/tasks/{task_id}/messages/{message_id}/cancel Stop the agent while it is writing this reply. Cancels the task the message belongs to, since the agent works on one reply at a time. Equivalent to `POST /tasks/{task_id}/cancel`. # Cancel a task Source: https://docs.biomni.phylo.bio/api-reference/pages/cancel-task api-reference/openapi.json POST /experimental/tasks/{task_id}/cancel Stop a running task. The body is optional. Omit it, or send `"force": false`, for a graceful stop. `"force": true` cancels immediately. # Create a project Source: https://docs.biomni.phylo.bio/api-reference/pages/create-project api-reference/openapi.json POST /projects Create a project to group related tasks and files. A project groups related tasks and holds the files they read and write. # Delete a project Source: https://docs.biomni.phylo.bio/api-reference/pages/delete-project api-reference/openapi.json DELETE /projects/{project_id} Delete a project and everything in it. Its tasks and files become inaccessible immediately. This cannot be undone. # Delete a task Source: https://docs.biomni.phylo.bio/api-reference/pages/delete-task api-reference/openapi.json DELETE /experimental/tasks/{task_id} Delete a task and its messages. The task becomes inaccessible immediately. Files the agent produced belong to the project and are not deleted. # Download a file Source: https://docs.biomni.phylo.bio/api-reference/pages/download-file api-reference/openapi.json GET /experimental/files/{file_id}/content Download an input or result file. Returns `302 Found` with a `Location` header pointing at a download link that expires in about 5 minutes. Use a client that follows redirects, such as `curl -L`. # Download a result Source: https://docs.biomni.phylo.bio/api-reference/pages/download-result api-reference/openapi.json GET /experimental/tasks/{task_id}/results/{result_id}/download Get a fresh download link for one of a task's result files. Returns a new `download_url` for one result file. The URLs returned by `GET /tasks/{task_id}/results` are short-lived; call this when one has expired. # Finalize an upload Source: https://docs.biomni.phylo.bio/api-reference/pages/finalize-upload api-reference/openapi.json POST /experimental/files/{file_id}/finalize Finish an upload so the file becomes available to the agent. Call this after sending the bytes to the `upload_url` from `POST /experimental/files`. Until then, the file is stored but not visible to tasks in the project. # Get a file Source: https://docs.biomni.phylo.bio/api-reference/pages/get-file api-reference/openapi.json GET /experimental/files/{file_id} Get metadata for one uploaded file. Returns metadata, not contents. Download the file with `GET /experimental/files/{id}/content`. # Get a message Source: https://docs.biomni.phylo.bio/api-reference/pages/get-message api-reference/openapi.json GET /experimental/tasks/{task_id}/messages/{message_id} Look up a single message by id. Works for a message you sent, an agent reply, or the `message_id` returned by a completed scientific review. A reply in progress has `status: "streaming"`; read it again for the content written since. # Get multipart part URLs Source: https://docs.biomni.phylo.bio/api-reference/pages/get-part-urls api-reference/openapi.json POST /experimental/files/{file_id}/parts Get upload URLs for a multipart upload's parts. Used only when `POST /experimental/files` returned `upload_type: "multipart"`. Pass the `upload_id` from that response and the part numbers you are about to upload; each one gets a PUT URL. You can request parts in batches. PUT each chunk to its URL, keep the `ETag` from each response, then pass every `{part_number, etag}` to `POST /experimental/files/{file_id}/finalize`. # Get a project Source: https://docs.biomni.phylo.bio/api-reference/pages/get-project api-reference/openapi.json GET /projects/{project_id} Get a project by id. # Get a task Source: https://docs.biomni.phylo.bio/api-reference/pages/get-task api-reference/openapi.json GET /experimental/tasks/{task_id} Get a task, its status, and any scientific reviews of it. A task settles at `completed`, `failed`, or `cancelled`. Read this endpoint again for its current status. | `status` | Meaning | | ----------- | ------------------------------------------- | | `idle` | No message has been sent yet | | `running` | The agent is working | | `completed` | The agent finished this turn | | `failed` | The latest agent message carries an `error` | | `cancelled` | You stopped the task | `reviews` holds the [scientific reviews](/api-reference/pages/review-task) of this task, each with its `status`, the `message_id` of the message holding the findings, and `error_message` on a failure. A review appears once it has written its findings. # List files Source: https://docs.biomni.phylo.bio/api-reference/pages/list-files api-reference/openapi.json GET /experimental/files List the files uploaded to a project. Returns metadata, not contents. Download a file with `GET /experimental/files/{id}/content`. Pass a file's `id` in `file_ids` on `POST /experimental/tasks/{id}/messages` to attach it to a task. # List messages Source: https://docs.biomni.phylo.bio/api-reference/pages/list-messages api-reference/openapi.json GET /experimental/tasks/{task_id}/messages List a task's messages in order, oldest first. Your messages have `role: "user"` and the agent's have `role: "assistant"`. Each agent reply is a single message whose `content[]` holds the whole reply: text, tool calls, and results. A reply still in progress has `status: "streaming"` with the content so far. `limit` (default 200, max 500) bounds the underlying events read, not the messages returned, so expect fewer messages than `limit`. The first page is the most recent stretch of the conversation. # List projects Source: https://docs.biomni.phylo.bio/api-reference/pages/list-projects api-reference/openapi.json GET /projects List your projects, newest first. A default project exists for unfiled tasks. # List task results Source: https://docs.biomni.phylo.bio/api-reference/pages/list-results api-reference/openapi.json GET /experimental/tasks/{task_id}/results List the files the agent produced under a task, each with a download link. Each file comes with a download URL. `reconcile` (default `true`) includes files the agent wrote during this request. `with_urls` (default `true`) attaches a download URL to each file. An unknown `task_id` returns `404`, so an empty `data` array means the task produced no files. # List skills Source: https://docs.biomni.phylo.bio/api-reference/pages/list-skills api-reference/openapi.json GET /experimental/skills List the skills you can run in a task. A skill is a packaged workflow from the Biomni catalog, such as a grounded literature review or a genome-editing design routine. This returns both built-in skills and your own. Pass an entry's `id` or `name` as `skill` on `POST /tasks/{id}/messages` to run it. `owner_type` is `system` for a built-in skill and `user` for one of your own. # List tasks Source: https://docs.biomni.phylo.bio/api-reference/pages/list-tasks api-reference/openapi.json GET /experimental/tasks List a project's tasks, newest first. # Run a scientific review Source: https://docs.biomni.phylo.bio/api-reference/pages/review-task api-reference/openapi.json POST /experimental/tasks/{task_id}/review Check a completed task's analysis for scientific accuracy. A reviewer agent re-reads a completed task's analysis and checks it for scientific accuracy, correct use of the data, unsupported claims, and stated limitations. A task that is `idle` or still `running` has nothing to review. The review runs in the background. This call returns immediately with `status: "running"` and does not return the review itself. When it finishes, a new entry appears in `reviews` on `GET /tasks/{task_id}`. Read the findings with `GET /tasks/{task_id}/messages/{message_id}` using that entry's exact `message_id`. Calling this while a review is running returns the running state. Calling it after a review finishes starts a new one that replaces the previous result. # Send a message Source: https://docs.biomni.phylo.bio/api-reference/pages/send-message api-reference/openapi.json POST /experimental/tasks/{task_id}/messages Send a message to the agent and get its reply. Sends to an existing task. Create one with `POST /tasks` first. If the agent is still working, the response holds the reply so far; the rest arrives on `GET /tasks/{task_id}/messages/{id}`. ### Model tier `model` sets the tier for a new task: * `standard`: the default balance of speed and capability * `fast`: lower latency on a lighter model * `max`: the highest-capability model An unknown value returns `422`. The tier is fixed when the task is created, so it is ignored when you pass `task_id`. `POST /tasks` does not accept a tier. ### Skills `skill` runs a skill on your message. Pass an id or name from [List skills](/api-reference/pages/list-skills); your `content` is the input. An unknown skill returns `404`. Ignored when you pass `task_id`. ### Attached files `file_ids` must reference files already finalized in the task's project. A file that cannot be read is skipped: the message still sends, without that attachment. # Start a task Source: https://docs.biomni.phylo.bio/api-reference/pages/start-task api-reference/openapi.json POST /experimental/tasks Create an idle task inside a project, or start it immediately with initial messages. The task shares the project's files and starts in `idle`. It stays idle until you send the first message with `POST /tasks/{id}/messages`, which moves it to `running`. Read its status with `GET /tasks/{id}` and stop it with `POST /tasks/{id}/cancel`. `model` picks the tier the agent runs on. It is fixed when the task is created and cannot be changed afterwards, so start a new task to work on a different tier. Omit it to take the default. Pass `initial_messages` to skip that second call: the messages are delivered to the task in the order you list them and the agent starts on the last one, reading the ones before it as the conversation so far. The task comes back as `running`. # Update a project Source: https://docs.biomni.phylo.bio/api-reference/pages/update-project api-reference/openapi.json PUT /projects/{project_id} Rename a project or edit its description. Only the fields you send change. Send an empty string, such as `"description": ""`, to clear a field. # Upload a file Source: https://docs.biomni.phylo.bio/api-reference/pages/upload-file api-reference/openapi.json POST /experimental/files Start an upload so the agent can use the file in a task. Uploads go directly to cloud storage. The API returns an upload target and never receives the bytes. The response's `upload_type` selects the flow and is chosen from the `size_bytes` you declare. ### `upload_type: "single"` 1. `POST /experimental/files` returns a `file_id`, an `upload_url`, and the `fields` to send with the bytes. 2. POST the bytes to `upload_url` as multipart form-data, with every key in `fields` included as a form field. Success returns `204 No Content`. 3. `POST /experimental/files/{file_id}/finalize` with an empty body. ### `upload_type: "multipart"` 1. `POST /experimental/files` returns a `file_id`, an `upload_id`, a `part_size_bytes`, and a `part_count`. 2. Split the file into `part_count` chunks of `part_size_bytes`. The last chunk is the remainder. 3. `POST /experimental/files/{file_id}/parts` with the `upload_id` and the part numbers you want, which returns a PUT URL per part. You can request them in batches. 4. PUT each chunk to its URL and keep the `ETag` response header for that part number. 5. `POST /experimental/files/{file_id}/finalize` with `{ "upload_id": "…", "parts": [{ "part_number": 1, "etag": "…" }, … ] }`. Once finalized, attach the `file_id` to a task with `file_ids` on `POST /experimental/tasks/{id}/messages`. # Authentication Source: https://docs.biomni.phylo.bio/api/authentication Create an API key and authenticate your requests to the Phylo API The Phylo API is currently in early access. To request access for your organization, contact your Phylo representative or [Phylo Support](mailto:support@phylo.bio). ## Create an API key A key acts within the workspace it was created in, with your own permissions in that workspace. 1. In [Biomni Lab](https://biomni.phylo.bio), open **Settings → API Keys**. 2. Click **Create key**, give it a name (e.g. `Batch analysis pipeline`), and optionally an expiration. Treat your API key like a password. Anyone with it can act as you within that workspace. ## Base URL For the self-serve platform, use: ``` https://api.phylo.bio/v1 ``` If you're an Enterprise customer, contact your Phylo representative for your API base URL. ## Authenticate a request Send the key as a **bearer token** in the `Authorization` header: ```bash curl theme={null} curl https://api.phylo.bio/v1/projects \ -H "Authorization: Bearer $PHYLO_API_KEY" ``` ```python Python theme={null} import os, requests BASE = "https://api.phylo.bio/v1" headers = {"Authorization": f"Bearer {os.environ['PHYLO_API_KEY']}"} resp = requests.get(f"{BASE}/projects", headers=headers) resp.raise_for_status() print(resp.json()) ``` ## Revoke a key From **Settings → API Keys**, **Revoke** disables a key immediately and permanently. Keys can carry an expiration. An expired key stops working automatically. ## Next steps Key → project → task → results, end to end. Status codes, error handling, and retries. # Errors Source: https://docs.biomni.phylo.bio/api/errors Status codes and error responses for the Phylo API All errors return the same body: ```json theme={null} { "type": "error", "error": { "type": "invalid_request_error", "code": "not_found", "message": "Project prj_01xxxxxxxxxxxxxxxxxxxxxx not found." } } ``` `code` is stable and machine-readable; `message` is not. On validation errors, `error.param` names the offending field. | Status | `error.type` | Meaning | | ------ | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | | `400` | `invalid_request_error` | Required fields are missing or invalid. | | `401` | `authentication_error` | The key is missing, malformed, revoked, or expired. Check the `Authorization` header and the key's status in **Settings → API Keys**. | | `403` | `permission_error` | The key is valid but lacks permission. A key acts with your permissions, in its own workspace. | | `404` | `invalid_request_error` | The project, task, or file id does not exist in this workspace. | | `422` | `invalid_request_error` | The request body failed validation. `error.param` names the field. | | `429` | `rate_limit_error` | Too many requests. | | `5xx` | `api_error` | Server error. | # Quickstart Source: https://docs.biomni.phylo.bio/api/quickstart From an API key to running an agent task and downloading its results The Phylo API is currently in early access. To request access for your organization, contact your Phylo representative or [Phylo Support](mailto:support@phylo.bio). ## Prerequisites * [A Phylo account](https://biomni.phylo.bio) with API access * [An API key](/api/authentication) The steps below assume your key is set as `PHYLO_API_KEY`: ```bash theme={null} export PHYLO_API_KEY="" ``` To test your API key, try listing projects: ```bash theme={null} curl https://api.phylo.bio/v1/projects \ -H "Authorization: Bearer $PHYLO_API_KEY" ``` Note that `https://api.phylo.bio/v1` is the self-serve base URL. If you're an Enterprise customer, contact your Phylo representative for your API base URL. ## Using a Biomni agent To get started, let's create a project. Projects group related tasks and files: ```bash theme={null} PROJECT_ID=$(curl -s -X POST https://api.phylo.bio/v1/projects \ -H "Authorization: Bearer $PHYLO_API_KEY" \ -H "Content-Type: application/json" \ -d '{"title": "BRCA1 variant workup"}' | jq -r '.id') ``` This returns something like: ```json theme={null} { "id": "prj_014OwAG97UY0UfcHlLHQRnKO", "type": "project", "title": "BRCA1 variant workup", "description": "", "created_at": "2026-08-12T21:21:01.919692Z", "updated_at": "2026-08-12T21:21:01.919698Z" } ``` Now that we have a project, let's start a task. A task is one conversation with the agent: ```bash theme={null} TASK_ID=$(curl -s -X POST https://api.phylo.bio/v1/experimental/tasks \ -H "Authorization: Bearer $PHYLO_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "project_id": "'"$PROJECT_ID"'", "title": "BRCA1 variant workup", "auto_mode": true, "initial_messages": [ {"role": "user", "content": "Look up the ClinVar status of BRCA1 variants rs80357065, rs28897696, and rs80357382, and write a short markdown summary report."} ] }' | jq -r '.id') ``` This returns something like: ```json theme={null} { "id": "tsk_017ilCeuDpMWTSH9Ah1syUGJ", "type": "task", "created_at": "2026-08-12T21:21:02.815306Z", "status": "running", "project_id": "prj_014OwAG97UY0UfcHlLHQRnKO", "title": "BRCA1 variant workup", "platform": "api" } ``` Now that the agent is working, let's check on it. `status` moves from `running` to `completed`, `failed`, or `cancelled`: ```bash theme={null} curl -s https://api.phylo.bio/v1/experimental/tasks/$TASK_ID \ -H "Authorization: Bearer $PHYLO_API_KEY" | jq -r '.status' ``` The full record returns something like: ```json theme={null} { "id": "tsk_017ilCeuDpMWTSH9Ah1syUGJ", "type": "task", "created_at": "2026-08-12T21:21:02.815000Z", "status": "completed", "project_id": "prj_014OwAG97UY0UfcHlLHQRnKO", "title": "BRCA1 variant workup", "platform": "api", "reviews": [] } ``` Agent tasks can run for hours, so design for long-running work rather than blocking a single request on the result. Now that the task is done, let's collect its output. Save the files the agent wrote: ```bash theme={null} curl -s "https://api.phylo.bio/v1/experimental/tasks/$TASK_ID/results?with_urls=true" \ -H "Authorization: Bearer $PHYLO_API_KEY" \ | jq -r '.data[] | .download_url + " -o " + .name' \ | xargs -L1 curl -s ``` The results list returns something like: ```json theme={null} { "type": "list", "data": [ { "type": "result_file", "result_id": "res_016YNAz7cvmPXcqvGoR1U57t", "name": "BRCA1_ClinVar_variant_summary.md", "size_bytes": 6149, "mime_type": "text/markdown", "message_id": null, "created_at": "2026-08-12T21:23:32Z", "download_url": "https://files.s3.us-west-2.amazonaws.com/...?X-Amz-Signature=..." } ], "has_more": false, "first_id": "res_016YNAz7cvmPXcqvGoR1U57t", "last_id": "res_016YNAz7cvmPXcqvGoR1U57t" } ``` `download_url` is presigned and short-lived, so fetch it soon after listing. Now that we have results, let's keep the conversation going. Ask a follow-up in the same task: ```bash theme={null} curl -s -X POST https://api.phylo.bio/v1/experimental/tasks/$TASK_ID/messages \ -H "Authorization: Bearer $PHYLO_API_KEY" \ -H "Content-Type: application/json" \ -d '{"content": "Which of those three variants has the strongest PARP inhibitor evidence?"}' ``` This returns your message and the agent's reply so far: ```json theme={null} { "type": "message_result", "user_message": { "id": "msg_f6872d1e0fb242fd", "type": "message", "task_id": "tsk_017ilCeuDpMWTSH9Ah1syUGJ", "created_at": "2026-08-12T21:26:51.413000Z", "role": "user", "content": [ {"type": "text", "text": "Which of those three variants has the strongest PARP inhibitor evidence?"} ], "platform": "api" }, "assistant_message": { "id": "msg_0e9eb143c44838c4", "type": "message", "task_id": "tsk_017ilCeuDpMWTSH9Ah1syUGJ", "created_at": "2026-08-12T21:26:28.611000Z", "role": "assistant", "content": [ { "type": "text", "text": "Searching PubMed and CIViC for PARP inhibitor and functional HDR evidence for each of the three BRCA1 variants." }, { "type": "tool_result", "tool_use_id": "toolu_01BmvmDbqJwohi5WxdBoWk17", "content": "{\"delivered\": true}" } ], "status": "streaming", "platform": "api", "input": {"user_message_id": "msg_f6872d1e0fb242fd", "file_ids": []} } } ``` ## Where to go next Congratulations, you just ran a Biomni agent! That loop is the foundation, and there is a lot more the agent can do: * [Upload a file](/api-reference/pages/upload-file) and attach it to a message with `file_ids`, so the agent works on your own data. * [Run a scientific review](/api-reference/pages/review-task) to have a reviewer agent check a finished task's analysis for scientific accuracy. * [Start a task](/api-reference/pages/start-task) with `plan_mode`, and the agent writes a plan for you to approve before it starts work. * [Errors](/api/errors) covers status codes, retries, and backoff. # Running a benchmark Source: https://docs.biomni.phylo.bio/api/recipes/running-a-benchmark A pattern for benchmarking Biomni through the Phylo API When running benchmarks, it can be helpful to manage them using the Phylo API. This example uses BiomniBench-DA task `da-18-7`, then starts a second Biomni task to score the result. When running this recipe with Opus 5, the benchmark took around 45 minutes. To make sure we use the specific model we chose for the full benchmark run, this recipe sets `disable_fallbacks`. This recipe launches two Biomni tasks for the benchmark: 1. The first task runs the BiomniBench-DA task 2. The second task grades the results from the first BiomniBench-DA task ## Prerequisites * [An API key](/api/authentication) * Python 3.10 or later with the `requests` package Install `requests`, then set your API key: ```bash theme={null} python -m pip install requests export PHYLO_API_KEY="" ``` The script uses `https://api.phylo.bio/v1`. If you're an Enterprise customer, set `PHYLO_BASE_URL` environment variable to the API base URL shared by your Phylo representative. ## Run the benchmark For the purposes of this recipe, we'll use the Python client recipe. Open [Building a Python client](/api/recipes/wrapping-the-api-in-python), save the client as `phylo_client.py`, and place it in the directory where you will run the benchmark. The benchmark imports `PhyloClient` from that file. Save this script – which includes prompts for the benchmark and scoring – as `benchmark.py` beside `phylo_client.py`: ```python benchmark.py theme={null} import json import tarfile from pathlib import Path import requests from phylo_client import PhyloClient PROMPT = """ To identify genomic mechanisms driving endocrine resistance, determine whether ESR1 mutations and MAPK pathway alterations are mutually exclusive or co-occurring in post-hormonal therapy HR+/HER2- tumors. The project contains three cBioPortal-format files from the public BiomniBench-DA task da-18-7: - data_clinical_sample.txt: Sample-level clinical annotations. Rows 1-4 are comment-prefixed metadata and the column header is on row 5. - data_cna.txt: A gene-by-sample discrete copy-number alteration matrix, where -2 is deep deletion and 2 is amplification. - data_mutations.txt: A Mutation Annotation Format table with gene, sample, protein-change, variant-classification, and read-count fields. Analyze the project files directly. Document the cohort selection, alteration definitions, statistical method, quantitative results, biological interpretation, and limitations. Save these two files under /mnt/results/: 1. trace.md with sections named Objective, Data Sources, Approach, Results, and References. Include the actual analysis code, rationale for analytical choices, and quantitative intermediate results. 2. answer.txt with a concise plain-text answer to the research question. The files come from the MSK-IMPACT cohort associated with "Genomic Landscape of Endocrine-Resistant Advanced Breast Cancers." Do not search for or read that paper, its figures, or its supplementary material. Solve the task from the project files and domain knowledge. """.strip() JUDGE_PROMPT = """ Score the BiomniBench-DA task da-18-7 response in the project files trace.md and answer.txt. Judge only the evidence in those two files. Do not redo the analysis, inspect another project's files, or use external sources. Choose exactly one listed level for each criterion. Do not award partial points between levels. 1. Cohort Selection (15 points) A, 15: Restricts the analysis to hormone receptor-positive, HER2-negative tumors collected after hormonal therapy and explains the selection. B, 7: Uses the correct receptor subtype but mixes primary and metastatic samples or mislabels some samples. C, 0: Does not restrict the analysis to the specified cohort. 2. ESR1 Ligand-Binding Domain Mutations (20 points) A, 20: Defines ESR1 LBD mutations as nonsynonymous variants within amino acids 300-550 and correctly identifies them in the data. B, 10: Identifies ESR1 mutations but does not restrict them to the LBD or misclassifies some variants. C, 0: Does not properly identify ESR1 LBD mutations. 3. MAPK Pathway Alterations (20 points) A, 20: Defines MAPK alterations as nonsynonymous mutations in ERBB2, NF1, EGFR, KRAS, HRAS, BRAF, and MAP2K1, plus NF1 deletions and EGFR amplifications, and correctly calls them. B, 10: Omits specified genes, copy-number events, or other required details. C, 0: Uses an incorrect gene set or misidentifies alterations. 4. Statistical Testing (20 points) A, 20: Constructs a 2-by-2 table of ESR1 LBD mutation status versus MAPK alteration status and performs a one-sided Fisher exact test for mutual exclusivity, reporting the p-value. B, 10: Constructs the table but uses an inappropriate test or does not state the direction. C, 0: Does not perform statistical testing. 5. Results Reporting (15 points) A, 15: Reports counts for ESR1 LBD only, MAPK only, both, and neither; gives the Fisher test p-value; and states whether co-occurrence is rare. B, 7: Reports some counts but omits the contingency table or p-value. C, 0: Does not report the required results. 6. Interpretation and Biological Context (10 points) A, 10: Interprets the result as evidence that ESR1 LBD mutations and MAPK alterations are largely mutually exclusive endocrine-resistance mechanisms and discusses therapeutic implications. B, 5: Interprets the result but omits biological context or therapeutic relevance. C, 0: Provides no interpretation or an incorrect conclusion. 7. Source Reliability (0 points, with penalties) A, 0: Values and identifiers are traceable to the project files or documented transformations, methods match the analysis, and external claims use identifiable references. B, -5: Most evidence is traceable, but some claims lack clear attribution. C, -10: Values, identifiers, or claims lack a clear source or are fabricated. Save the result as raw JSON at /mnt/results/score.json using this shape: { "benchmark_task": "da-18-7", "total_score": 0, "criteria": [ { "criterion": "Cohort Selection", "level": "A", "points": 15, "max_points": 15, "reason": "Evidence-based explanation" } ], "summary": "Concise overall assessment" } Include all seven criteria. Set total_score to the point sum clamped to the 0-100 range. Do not wrap the JSON in a Markdown code fence. """.strip() def stage_benchmark_files(): archive_url = ( "https://datahub.assets.cbioportal.org/breast_msk_2018.tar.gz" ) archive_path = Path("breast_msk_2018.tar.gz") filenames = ( "data_clinical_sample.txt", "data_cna.txt", "data_mutations.txt", ) timeout_seconds = 60 response = requests.get(archive_url, timeout=timeout_seconds) response.raise_for_status() archive_path.write_bytes(response.content) paths = [] with tarfile.open(archive_path) as archive: for filename in filenames: path = Path(filename) source = archive.extractfile(f"breast_msk_2018/{filename}") path.write_bytes(source.read()) paths.append(path) print(f"Staged: {path}") return paths def run_benchmark_task(phylo, input_paths): # Call the Phylo API to create a project for the benchmark run. project = phylo.create_project( title="Breast-cancer endocrine resistance benchmark", description="ESR1 and MAPK alteration mutual exclusivity", ) project_id = project["id"] print(f"Created project: {project_id}") for input_path in input_paths: # Call the Phylo API to upload each benchmark input to the project. phylo.upload_file(project_id, input_path) print(f"Uploaded: {input_path.name}") # Call the Phylo API to create and start the benchmark task. task = phylo.create_task( project_id=project_id, title="BiomniBench-DA task da-18-7", initial_messages=[{"role": "user", "content": PROMPT}], model="custom:claude-opus-5", disable_fallbacks=True, auto_mode=True, ) task_id = task["id"] print(f"Started task: {task_id}") # Poll the Phylo API until the benchmark task finishes. phylo.wait_for_task(task_id) # Call the Phylo API to download the benchmark task's result files. output_directory = phylo.download_results( task_id, Path("benchmark-results") / task_id, ) print(f"Benchmark results: {output_directory}") return task_id, output_directory def score_results_with_llm_judge(phylo, benchmark_task_id, output_directory): # Call the Phylo API to create an isolated project for the judge. judge_project = phylo.create_project( title="Breast-cancer endocrine resistance benchmark judge", ) judge_project_id = judge_project["id"] print(f"Created judge project: {judge_project_id}") for filename in ("trace.md", "answer.txt"): # Call the Phylo API to upload each candidate result for judging. phylo.upload_file(judge_project_id, output_directory / filename) # Call the Phylo API to create and start the judge task. judge_task = phylo.create_task( project_id=judge_project_id, title=f"Score BiomniBench-DA task da-18-7 run {benchmark_task_id}", initial_messages=[{"role": "user", "content": JUDGE_PROMPT}], model="custom:claude-opus-5", disable_fallbacks=True, auto_mode=True, ) judge_task_id = judge_task["id"] print(f"Started judge task: {judge_task_id}") # Poll the Phylo API until the judge task finishes. phylo.wait_for_task(judge_task_id) # Call the Phylo API to download the judge task's result files. judge_output_directory = phylo.download_results( judge_task_id, output_directory / "judge", ) score_path = judge_output_directory / "score.json" score = json.loads(score_path.read_text()) print(f"Judge score: {score['total_score']}/100") print(f"Judge details: {score_path}") def main(): phylo = PhyloClient() input_paths = stage_benchmark_files() task_id, output_directory = run_benchmark_task(phylo, input_paths) score_results_with_llm_judge(phylo, task_id, output_directory) if __name__ == "__main__": main() ``` Run the benchmark from the directory containing both Python files: ```bash theme={null} python benchmark.py ``` The script downloads the public cBioPortal study archive, then stages and uploads three benchmark files totaling about 4.8 MB. The first task runs the BiomniBench-DA task, and the second task grades its results. Candidate output is saved under `benchmark-results//`; judge output is saved in its `judge/` subdirectory. ## Adapting this for your benchmark To adapt this to your benchmark, you can either: 1. Replace `PROMPT` and `JUDGE_PROMPT` with your benchmark prompt and rubric. 2. Use this as a base for a larger distributed benchmark. If you choose to launch multiple benchmark tasks at once, you may hit the limits for your account. These will be reflected as `429` errors from either the Phylo API or internal tools used by the Biomni agent, such as tasks spawned on the HPC. If you encounter these errors, limit the number of tasks you start with the Phylo API. Happy benchmarking! # Building a Python client Source: https://docs.biomni.phylo.bio/api/recipes/wrapping-the-api-in-python Until we have an official Python SDK, if you'd like to use a Python library rather than interacting directly with the API, you can use this recipe for a basic Python SDK for the Phylo API. ## Prerequisites * [An API key](/api/authentication) * Python 3.10 or later with the `requests` package Install `requests`, then set your API key: ```bash theme={null} python -m pip install requests export PHYLO_API_KEY="" ``` To use another API base URL, set the `PHYLO_BASE_URL` environment variable. ## Functions in this recipe * `create_project()`: Creates a project. * `list_projects()`: Lists projects in the API key's workspace. * `create_task()`: Creates a task in `max` and Auto mode by default, with optional initial messages. * `upload_file()`: Uploads files. * `send_message()`: Sends a message and optional file attachments to a task. * `get_task()`: Gets the current task status and metadata. * `wait_for_task()`: Polls until a task completes, fails, or is cancelled. * `download_results()`: Downloads every result file from a completed task. ## Create the client Copy this file and save it as `phylo_client.py`: ```python phylo_client.py theme={null} import json import mimetypes import os import time from pathlib import Path, PurePosixPath import requests PHYLO_BASE_URL = os.getenv("PHYLO_BASE_URL", "https://api.phylo.bio/v1") REQUEST_TIMEOUT_SECONDS = 60 POLL_INTERVAL_SECONDS = 15 TASK_TIMEOUT_SECONDS = 24 * 60 * 60 TERMINAL_TASK_STATUSES = {"completed", "failed", "cancelled"} class PhyloClient: def __init__(self, api_key=None, api_base=None): self.api_base = (api_base or PHYLO_BASE_URL).rstrip("/") self.session = requests.Session() self.session.headers["Authorization"] = ( f"Bearer {api_key or os.environ['PHYLO_API_KEY']}" ) def _request(self, method, path, **kwargs): response = self.session.request( method, f"{self.api_base}{path}", timeout=REQUEST_TIMEOUT_SECONDS, **kwargs, ) response.raise_for_status() return response.json() if response.content else {} def list_projects(self): return self._request("GET", "/projects") def create_project(self, title, description=None): body = {"title": title} if description is not None: body["description"] = description return self._request("POST", "/projects", json=body) def create_task( self, project_id, title=None, initial_messages=None, model="max", auto_mode=True, disable_fallbacks=False, ): body = { "project_id": project_id, "auto_mode": auto_mode, "disable_fallbacks": disable_fallbacks, } if title is not None: body["title"] = title if initial_messages is not None: body["initial_messages"] = initial_messages if model is not None: body["model"] = model return self._request("POST", "/experimental/tasks", json=body) def upload_file(self, project_id, path, mime_type=None): path = Path(path) mime_type = ( mime_type or mimetypes.guess_type(path.name)[0] or "application/octet-stream" ) intent = self._request( "POST", "/experimental/files", json={ "project_id": project_id, "filename": path.name, "size_bytes": path.stat().st_size, "mime_type": mime_type, }, ) if intent["upload_type"] != "single": raise RuntimeError("This client only handles single-part uploads.") with path.open("rb") as file_handle: upload = requests.post( intent["upload_url"], data=intent["fields"], files={"file": (path.name, file_handle, mime_type)}, timeout=REQUEST_TIMEOUT_SECONDS, ) upload.raise_for_status() self._request( "POST", f"/experimental/files/{intent['file_id']}/finalize", json={}, ) return intent["file_id"] def send_message(self, task_id, content, file_ids=None): return self._request( "POST", f"/experimental/tasks/{task_id}/messages", json={"content": content, "file_ids": file_ids or []}, ) def get_task(self, task_id): return self._request("GET", f"/experimental/tasks/{task_id}") def wait_for_task( self, task_id, timeout_seconds=TASK_TIMEOUT_SECONDS, poll_interval_seconds=POLL_INTERVAL_SECONDS, ): deadline = time.monotonic() + timeout_seconds while time.monotonic() < deadline: task = self.get_task(task_id) status = task["status"] print(f"Task status: {status}") if status in TERMINAL_TASK_STATUSES: if status != "completed": raise RuntimeError(f"Task ended with status: {status}") return task time.sleep(poll_interval_seconds) raise TimeoutError(f"Task did not finish within {timeout_seconds} seconds") def download_results(self, task_id, output_directory): output_directory = Path(output_directory).resolve() output_directory.mkdir(parents=True, exist_ok=True) after_id = None downloaded_count = 0 while True: params = {"with_urls": "true"} if after_id is not None: params["after_id"] = after_id page = self._request( "GET", f"/experimental/tasks/{task_id}/results", params=params, ) for result in page["data"]: name = result["name"] relative_path = PurePosixPath(name) if ( not relative_path.parts or relative_path.is_absolute() or ".." in relative_path.parts or "\\" in name ): raise ValueError(f"Unsafe result path: {name}") output_path = output_directory.joinpath(*relative_path.parts) output_path.parent.mkdir(parents=True, exist_ok=True) if output_directory not in output_path.resolve().parents: raise ValueError(f"Unsafe result path: {name}") if output_path.exists(): raise FileExistsError(f"Result path already exists: {output_path}") response = requests.get( result["download_url"], timeout=REQUEST_TIMEOUT_SECONDS, ) response.raise_for_status() output_path.write_bytes(response.content) downloaded_count += 1 print(f"Downloaded: {output_path}") if not page["has_more"]: break after_id = page["last_id"] if downloaded_count == 0: raise RuntimeError("The task completed without result files.") return output_directory if __name__ == "__main__": print(json.dumps(PhyloClient().list_projects(), indent=2)) ``` Run it to verify your API key by listing your projects: ```bash theme={null} python phylo_client.py ``` To import it, place `phylo_client.py` beside your script: ```python theme={null} # some-directory/ # ├── phylo_client.py # └── benchmark.py # The file where you're importing phylo_client from phylo_client import PhyloClient phylo = PhyloClient() project = phylo.create_project(title="My API project") print(project["id"]) ``` # FAQ Source: https://docs.biomni.phylo.bio/faq Frequently asked questions about Biomni Lab Find answers to common questions about using Biomni Lab. ## General Biomni Lab is an AI-powered research assistant designed for biomedical and life sciences research. It combines large language models with specialized bioinformatics tools, databases, and computational resources to help you analyze data and accelerate your research. No. Biomni Lab is designed to be accessible to researchers at all skill levels. You can describe what you want to accomplish in plain language, and Biomni Lab will handle the technical details. However, having domain knowledge about your research area helps you ask better questions and interpret results. Biomni Lab specializes in biomedical and life sciences research, including: * Genomics and transcriptomics * Proteomics and structural biology * Single-cell analysis * Pathway and network analysis * Biostatistics and machine learning * Literature and database searches ## Trust & Accuracy Yes. We do not share your data with other users. See our privacy policy for details. Biomni Lab is built with multiple safeguards to ensure accurate, reliable results: **Citations & References** * All database queries link directly to source records (UniProt, NCBI, PDB, etc.) * Literature references include DOIs and links to published papers * Tool parameters and methods are documented with official references **Review Mode** * Click the **Review** button at the top of any session to verify results * See all claims with their supporting evidence * Check data sources and identify assumptions **Hallucination Guardrails** * Claims are cross-referenced against authoritative databases * Uncertain results are flagged with confidence indicators * Input/output data is validated against expected formats * All steps are logged for reproducibility While these measures significantly reduce errors, we recommend verifying critical findings through independent sources—especially for clinical applications or publication-ready research. Use the **Review** button at the top of any session to enter review mode. This shows: * All claims and statements with supporting evidence * Direct links to database records and literature * Data sources used in the analysis * Any assumptions or caveats You can also ask Biomni Lab to explain its reasoning or provide additional citations for any claim. ## Files & Data Biomni Lab supports common bioinformatics formats including: * **Sequences**: FASTA, FASTQ, FASTQ.GZ * **Alignments**: SAM, BAM, CRAM * **Variants**: VCF, BCF, GVCF * **Tabular**: CSV, TSV, XLSX, TXT * **Annotations**: GFF, GTF, BED * **Images**: PNG, JPG, SVG, PDF The maximum file size is 10 GB per file. Contact support if you need to process larger files. Files are stored for the duration of your account and can be downloaded or deleted at any time. Yes. Biomni Lab supports gzip-compressed files (.gz) for sequences and other large files. This is recommended for FASTQ files to save upload time and storage space. ## Analysis & Tools Biomni Lab has access to many popular tools including: * **Alignment**: Bowtie2, BWA, STAR, HISAT2 * **Variant calling**: GATK, BCFtools, FreeBayes * **RNA-seq**: DESeq2, edgeR, featureCounts * **Single-cell**: Seurat, Scanpy * **Structure**: AlphaFold * **Visualization**: ggplot2, matplotlib, seaborn See the [Resources](/features/resources) page for a complete list. Analysis time varies depending on: * Data size and complexity * Tools being used * Current system load Simple queries complete in seconds. Alignment of a typical RNA-seq sample takes 10-30 minutes. Large genome analyses may take several hours. Biomni Lab shows progress updates during long-running tasks. Biomni Lab can write and execute Python and R code for your analyses. If you have specific requirements, you can ask Biomni Lab to implement custom analysis pipelines. However, you cannot upload and run arbitrary executable files for security reasons. ## Compute & Limits Each analysis session has access to: * **CPU**: Multi-core processing for parallel computations * **Memory**: Sufficient RAM for most bioinformatics workflows * **GPU**: Available for specific tools (marked with HPC badge) like AlphaFold and deep learning models * **Storage**: Temporary workspace for intermediate files during analysis Pro users get higher resource limits across the board. See the [Pricing FAQ](/pricing-faq) for details. Yes. Usage is tracked based on the underlying LLM and compute resources consumed — not a simple message count. Each plan has a daily usage allowance that resets every day, and Pro users get 10x the daily allowance of Free users. You can also run multiple sessions concurrently (Free: up to 5, Pro: up to 10). You can check your current usage on the [Settings](https://biomni.phylo.bio/settings) page. * **Daily usage limit**: Your tasks are queued until your usage resets the next day. See the [Pricing FAQ](/pricing-faq) for more details. * **File size limit**: Upload will fail with an error message. Try compressing the file or contact support. * **Storage limit**: You'll need to delete files before uploading more. Download important results first. ## Projects & Organization * **Quick Task**: A standalone analysis session for one-off questions or explorations. Good for trying things out. * **Project**: An organized workspace for related analyses. Projects help you keep files, tasks, and results organized for ongoing research. Yes. Go to [Settings](https://biomni.phylo.bio/settings) → Projects and pick a project. You can set: * **Project context** — what the agent should know before starting any task here, such as the organism, assay, or dataset you work with * **Custom instructions** — how the agent should respond in this project, for example always showing the code it ran * **Auto attached skills** — skills added to the first message of every new task in the project These apply to tasks created from then on. Anyone can still attach other skills task by task. As few as you genuinely need every time. Every auto attached skill is read at the start of every task in the project, even when that task does not use it — taking up context and increasing the odds the agent follows the wrong instruction. Attach the rest task by task instead. Yes. You can invite team members to your organization and share projects with them. Team members can view and contribute to shared projects while keeping personal work private. Yes. All results can be downloaded including: * Generated files (BAM, VCF, CSV, etc.) * Figures and visualizations * Analysis reports * Chat transcripts ## Account & Billing For detailed pricing, plan comparisons, academic discounts, and billing questions, see the **[Pricing FAQ](/pricing-faq)**. Contact [support@phylo.bio](mailto:support@phylo.bio) to manage your account. Your data will be retained for 30 days after cancellation. ## Troubleshooting * Check that your input files are in the correct format * For large files, ensure they're compressed (.gz) * Consider breaking the analysis into smaller batches * Contact support if an analysis seems stuck * Be more specific about what you want to accomplish * Mention your input files using @ references * Specify the tools or methods you want to use * Break complex requests into smaller steps * See [How to Prompt](/how-to-prompt) for detailed tips * Check the error message for specific issues (wrong file format, missing data, etc.) * Try rephrasing your request with more details * If the error persists, report it using the bug icon in the top-right corner * Check the [Bug Reporting](/support/bug-reporting) page for more information Common causes: * File exceeds size limit * Unsupported file format * Network interruption * File is corrupted Try compressing large files, checking the format, and ensuring a stable connection. ## Still Have Questions? * **[Join our Slack](https://join.slack.com/t/biomnigroup/shared_invite/zt-478z7aarm-~JC0jFpGZZorug6FhcuZFA)** - Chat with the community and Biomni Lab team * **[Contact Support](/support/customer-support)** - Get help from our support team * **[Report a Bug](/support/bug-reporting)** - Let us know if something isn't working # Cloud Storage Source: https://docs.biomni.phylo.bio/features/cloud-storage Bring files into a project from connected drives or public links Cloud imports copy selected external files into the current project. Available sources depend on your plan and workspace. ## Import files into a project From a task: 1. Select **+ Add** in the composer. 2. Choose **Import from cloud storage**. 3. Connect a provider, paste a supported public link, or select an available source. 4. Choose the files or folders to import. 5. Wait for the import to finish before asking Biomni to use the files. Imported files are copied into Biomni-managed project storage. They then behave like other project files: authorized project members can browse, preview, download, and attach them according to their project role. Cloud imports support provider connections and selected public links, including Google Drive, Dropbox, and S3 sources. The exact choices shown in the dialog can vary by workspace. A cloud import is a copy. Updating the source file later does not automatically update the imported project file. ## Choose the right option | Goal | Use | | -------------------------------------- | ---------------------------- | | Work on a stable copy inside a project | Cloud import | | Attach a local file or folder | Upload files / Upload folder | | Keep generated output with the task | Results | For project file organization, see [Projects & Drive](/features/projects-and-drive). # Collaboration Source: https://docs.biomni.phylo.bio/features/collaboration Share projects with members of your Team workspace Team workspaces can share a project with selected active members or with the whole workspace. Personal workspaces remain private. Project sharing includes the project's tasks, files, results, notes, Drive content, and other project-owned resources. Access is checked against current workspace membership. Chat access handoff is a beta feature and appears only in environments where it has been enabled. ## Access levels | Role | What it allows | | ---------- | --------------------------------------------------------------------------------------------- | | **Viewer** | Read tasks, files, notes, and results | | **Editor** | Create tasks, continue chats handed to them, upload files, and change project content | | **Admin** | Manage access and project settings, and delete the project when deletion requirements are met | Every task has one person with chat access who can send messages and control it. That person can hand off chat access to an active project Editor or Admin after the current response finishes when the task belongs to a shared project. The handoff button is in the task header next to Share; for unshared projects it is disabled and explains that only sessions in shared projects can be transferred. The previous participant immediately becomes read-only. Project Admins can reassign chat access if the current participant is no longer available. Session notes and creator attribution remain with the original task creator. ## Share a project If you are a project Admin: 1. Open the project menu. 2. Select the sharing or member-management action. 3. Add a workspace member and choose Viewer, Editor, or Admin. 4. Save the changes. Where enabled, you can also grant the entire workspace Viewer or Editor access. Admin access must be assigned to an individual member. ## Working in a shared project * Tasks display their creator and the participant with chat access. * The current participant can use **Hand off chat access** to let one Editor or Admin continue the conversation. Multiple members cannot send messages at the same time. * Project files and results inherit the project's access level. * Viewers can open and download accessible files but cannot start compute or change project content. * Editors can create their own tasks and add files, but cannot change sharing or project-wide instructions. * Project context, custom instructions, and auto attached Skills are visible to members; only Admins can edit them. Removing a member's project access stops future access but does not delete work they created. Project deletion is blocked while other members still own project tasks/files or while compute and billing activity is unsettled. For project structure and settings, see [Projects & Drive](/features/projects-and-drive). # MCP Connectors Source: https://docs.biomni.phylo.bio/features/connectors Connect external tools and services so the agent can use them in your tasks MCP connectors let Biomni Lab work with approved external tools and services directly inside a task. Once you connect an account, the agent can call that service's tools on your behalf: opening issues, reading pull requests, updating projects, and more. Model Context Protocol (MCP) is an open standard for connecting AI agents to external tools. Any compatible service that your organization makes available can be connected to Biomni Lab. Connectors are set up per person. Connecting an account only lets the agent see what that account can already see—and only while it is working on a task you started. ## Available connectors Your organization chooses which connectors are available. Open **Settings → Connectors** to see the current catalog for your workspace. Organization admins can also add **custom connectors** for compatible MCP servers—see [For organization admins](#for-organization-admins). If you don't see any connectors under **Settings → Connectors**, an organization admin may need to enable one first. Feature availability and the built-in connector catalog vary by workspace. ## Connecting a connector 1. Open **Settings → Connectors**. 2. Find the connector under **MCP Connectors** and click **Connect**. 3. Complete sign-in using one of the methods below. A popup opens to the service's sign-in page. Approve access, and the popup closes automatically. The row updates to show a **Connected** badge and the account you linked. Settings Connectors panel showing the MCP Connectors card with GitHub in the Connected state If nothing happens when you click **Connect**, your browser may have blocked the popup. Allow popups for this site, then try connecting again. Some custom connectors ask for a token instead of a popup. Paste a personal access token for the service and click **Connect**. Your token is stored encrypted and used only to call that server's tools on your behalf. Connect dialog with a Personal access token field ## Using connector tools in a task Once connected, just describe what you want—the agent picks the right tool automatically. You don't need to `@` mention anything. ```text theme={null} Open a GitHub issue in acme/genome-pipeline titled "Add a QC step" and summarize the three most recent open issues. ``` The agent only uses connectors you've connected, and only the tools you've left enabled. ## Choosing which tools the agent can use Each connected server exposes a set of tools. Expand **Tools** on a connected row to see them, grouped into **Read-only** and **Write**. Every tool has a switch—toggle one off to stop the agent from using it. Expanded Tools panel with per-tool switches and a Refresh button Want the agent to look but not touch? Turn off the **Write** tools and leave **Read-only** on. State the same restriction in your request. Click **Refresh** to re-fetch the tool list if the server has changed. ## Disconnecting Click **Disconnect** on a connected row to remove your account and stop the agent from using that server. You can reconnect anytime. ## For organization admins Admins and owners control which connectors the whole organization can use. Manage the workspace connector catalog under **Settings → Connectors**. ### Enabling a connector Toggle a connector's switch on to make it available to your members. They'll then see it under **Settings → Connectors** and can connect their own accounts. Toggle it off to hide it again. Admin connector list with enable switches and an Add custom connector button ### Adding a custom connector Connect any MCP server your team runs or subscribes to: 1. Click **Add custom connector**. 2. Fill in the details: * **Name** — how the connector appears to members (e.g. *My Company API*) * **Server URL** — the server's MCP endpoint (e.g. `https://mcp.example.com/mcp`) * **Authentication** — how members sign in: * **OAuth (dynamic registration)** — members sign in through the server's OAuth flow * **Personal access token** — each member pastes their own token * **Description** *(optional)* 3. Click **Add connector**. Add a custom MCP server dialog with Name, Server URL, and Authentication fields The connector appears in the list with a **Custom** badge, ready for members to connect. ### Removing a custom connector Click the delete icon on a custom connector and confirm. Built-in connectors can't be deleted—only disabled. Deleting a custom connector removes it for the whole organization and disconnects every member's connection to it. This can't be undone. ## Security & privacy * **Per-person connections.** Connecting is per user; the agent only ever acts with your own access. * **Encrypted at rest.** OAuth tokens and personal access tokens are stored encrypted. * **Used only during your tasks.** The agent calls connector tools on your behalf while working on a task you started. * **You stay in control.** Disable individual tools or disconnect at any time. Admins control which connectors exist for the organization. Never paste an external-service credential into a task message or personal instruction. Enter it only in the connector's credential flow. # Personalization & Memory Source: https://docs.biomni.phylo.bio/features/memory Set persistent preferences and project-specific instructions Biomni uses conversation context, personal instructions, and project settings at different scopes. Choose the narrowest scope that fits the instruction. ## Conversation context Within a task, Biomni can use earlier messages, attached files, and generated results. Keep follow-up refinements in the same task: ```text theme={null} Use the same filtered cohort, but stratify the result by treatment arm. ``` Start a new task when the goal or evidence boundary changes substantially. ## Personal instructions Open your avatar menu and choose **Personalization**, or open the Personalization section in Settings. Add durable preferences such as: * preferred programming language; * desired figure or report format; * terminology and units to use; or * response conventions you want across tasks. Personal instructions are stored for your user in the active workspace and are included when Biomni starts work. You can edit or remove them at any time. Write preferences as direct instructions: “Use R for statistical analysis” is clearer than “I sometimes prefer R.” ## Project settings Use **Settings → Projects** for context or instructions that apply only to one project. Project settings include: * project context; * ordered custom instructions; and * auto attached Skills for the first message of new tasks. Project instructions are more specific than personal instructions. Changes are captured by new tasks and do not rewrite existing conversations. ## What not to store Do not put passwords, API keys, access tokens, private keys, or other credentials in personal or project instructions. Use approved connection and secret-management flows instead. For project-level configuration, see [Projects & Drive](/features/projects-and-drive). # Models & Compute Source: https://docs.biomni.phylo.bio/features/models-and-compute Choose a model profile and understand how Biomni runs computational work Biomni separates the model that plans and reasons from the compute that runs code, scientific tools, and larger pipelines. ## Model profiles When the model selector is available, choose a profile from the composer: | Profile | Best for | Usage | | ------------ | ------------------------------------------------ | ---------------------- | | **Standard** | Everyday research and analysis | Lowest quota use | | **Fast** | Lower-latency work on a lighter model | Intermediate quota use | | **Max** | The most demanding reasoning and multimodal work | Highest quota use | The profiles and models available to you can vary by plan and workspace. Some workspaces also expose a **Custom** submenu with direct model choices. You can change the profile for an existing task when the agent is idle. A busy task keeps its current profile until that run finishes. Start with Standard. Move to Fast when latency matters more than depth, or Max when the task needs stronger reasoning, image/PDF input, or a difficult review. ## Computational work Biomni runs code in an isolated cloud workspace. It can use Python, R, and shell tools, create files, and execute notebook cells. For larger workloads it can start additional CPU, high-memory, or GPU machines and submit supported HPC tools and pipelines. Examples include: * parallel processing across samples; * high-memory assembly and genomics workflows; * GPU-backed structure prediction and design; and * versioned nf-core pipelines for common sequencing analyses. You do not need to select a machine manually for ordinary work. Describe the dataset and constraints; Biomni chooses an execution approach and reports long-running background activity in the task. ## Usage and concurrency Model calls and compute both contribute to usage. A complex task can consume more than a short question even when each begins with one message. Plan limits and concurrent-task capacity are shown in Biomni Lab and vary by plan. See the [Pricing FAQ](/pricing-faq) for self-serve plan and billing details. # Projects & Drive Source: https://docs.biomni.phylo.bio/features/projects-and-drive Organize related tasks, files, results, and project-wide instructions Projects keep related research in one place. Each project contains tasks and project-scoped files; it can also provide context, instructions, and default Skills to every new task. ## Quick Tasks and named projects **Quick Tasks** is the default project for one-off work. It behaves like a normal project, including file sharing between its tasks. Create a named project when work has a durable research question, dataset, or team. Open the project selector in the sidebar and choose **Create a new project**. ## Tasks A task is one conversation with Biomni. Within a project, each task has its own: * message and execution history; * generated results; * plan, compute activity, and notes; and * model profile. The project sidebar shows its tasks and current activity. Use separate tasks for analyses with different goals or assumptions; keep follow-up refinement in the same task. ## Project files and Results Uploaded and imported files belong to a project. Biomni can use project files in that project's tasks, and you can select an existing file from **+ Add** without uploading it again. Generated task output appears in **Results** and remains associated with the project. Depending on the file type, you can preview, download, rename, move, or delete it. Internal execution artifacts are hidden from normal file views. Access follows the project. A file from another project must be copied, imported, or explicitly selected through an available product flow before the current task can use it. ## Drive Drive is the project-level file browser. Use it to: * browse folders, uploads, and generated files; * upload files or folders; * preview and download supported formats; * rename, move, or delete content when your role permits; and * inspect project file activity. Cloud imports copy external files into project storage. See [Cloud Storage](/features/cloud-storage) for supported import flows. ## Project settings Open **Settings → Projects** and select a project. ### Project context Describe durable facts Biomni should know in every new task, such as the study, organism, assay, cohort, or dataset conventions. ### Custom instructions Set project-specific response or workflow requirements. These are more specific than personal instructions but cannot override safety controls. ### Auto attached Skills Choose Skills that should be attached to the first message of every new task. Keep this list short and limited to workflows the project genuinely uses by default. Project settings are captured when a task is created. Editing them affects new tasks; existing tasks keep the context, instructions, and Skill versions they started with. ## Collaboration Team workspaces can share a project as Viewer, Editor, or Admin. Project tasks and files inherit that access, with additional creator-only rules for steering a task and editing its notes. See [Collaboration](/features/collaboration) for the complete role model. # Resources Source: https://docs.biomni.phylo.bio/features/resources Point Biomni at scientific databases, software, HPC tools, and pipelines Resources tell Biomni which scientific database, software package, command-line tool, or managed compute tool you want it to consider. The live Resources browser is the source of truth for the catalog available in your workspace. It is updated more often than this guide and can vary by plan. ## Browse resources Open **Resources** from the main navigation, or select **+ Add → Resources** in a task. Type `@` in the composer to search the same resource catalog alongside available files. Resources are grouped into: * **Databases** — scientific data sources such as PubMed, UniProt, PDB, Ensembl, ClinVar, GEO, Open Targets, and GWAS Catalog. * **Tools** — managed scientific functions, HPC tools, and versioned pipelines. * **Software** — Python, R, and command-line packages available for code-based analysis. Select a resource to add it to the message, then describe how it should be used: ```text theme={null} Search @PubMed for randomized studies published since 2022 on this intervention. Build an evidence table with population, endpoint, effect size, and limitations. ``` ```text theme={null} Use @STAR for alignment and explain the reference build and parameters before submitting the run. ``` ## Attaching a resource does not run it A resource is context for the request. Biomni still chooses and executes the appropriate tool calls while working. If you require a specific method, say so explicitly and explain any fixed parameters or validation criteria. You usually do not need to attach common software by name. Attach a resource when the source or method is part of the scientific requirement. ## Managed compute and pipelines Compute-intensive tools and nf-core pipelines run outside the ordinary analysis workspace. Biomni searches the current registry, reads the selected tool or pipeline guide, submits the job, and reports completion back to the task. Availability, versions, GPU types, and resource limits can change by plan and workspace. Use the in-product catalog rather than a copied tool list when planning a workflow. ## Resources versus Skills A **Resource** identifies something Biomni can use. A **Skill** supplies a reusable workflow for how to approach a class of task. You can use both in the same request. See [Skills & Capabilities](/features/skills-and-capabilities) for examples. # Scientific Review Source: https://docs.biomni.phylo.bio/features/scientific-review Ask a second agent to critique a completed Biomni response Scientific Review asks a separate reviewer agent to examine a completed response. The reviewer looks for scientific errors, unsupported claims, incorrect use of data, missing limitations, and places where the evidence does not support the conclusion. ## Run a review 1. Wait for Biomni to finish its response. 2. Select **Review** on the latest answer. 3. Keep the task open or continue elsewhere while the review runs in the background. 4. Read the review when it appears beneath the answer. Only one scientific review runs at a time for a task. The Review action is not available while the agent is still working or when there is no completed answer to assess. ## Use the findings Treat the review as a critique, not a certification. It can identify issues and suggest corrections, but it is still generated by an AI system. Useful follow-ups include: ```text theme={null} Address the review's concerns about the control group and rerun the analysis. ``` ```text theme={null} Which review findings change the conclusion, and which only affect presentation? ``` ```text theme={null} Create a revised report that distinguishes observed results from interpretation. ``` ## Review checklist for important work For clinical, regulatory, safety-critical, or publication-ready work: * inspect the underlying data and generated files; * open and verify cited sources; * confirm tool versions, parameters, and statistical assumptions; * reproduce key calculations independently; and * have a qualified human review the final conclusions. Scientific Review reduces the chance that an issue goes unnoticed. It does not replace expert review or independent validation. # Skills & Capabilities Source: https://docs.biomni.phylo.bio/features/skills-and-capabilities Start from a proven scientific workflow or explore what Biomni can do Biomni combines a general research agent with reusable **Skills** and a browsable catalog of **Capabilities**. Use a Skill when you want a tested workflow with clear instructions. Browse Capabilities when you want examples of the research questions Biomni can handle. ## Skills A Skill is a packaged workflow for a specific kind of work. It can include instructions, supporting references, scripts, and expected outputs. To use one in a task: 1. Select **+ Add** in the composer. 2. Choose **Skills**. You can also type `+` in the composer. 3. Search or browse the catalog. 4. Select a Skill to attach it, then describe your data and goal. The attached Skill appears in your message. Biomni reads it when it starts that turn and follows its workflow alongside your request. Attach only the Skills that are relevant to the current task. Extra instructions consume context and can pull the analysis in competing directions. ### Project-attached Skills Project admins can make selected Skills apply automatically to the first message of each new task: 1. Open **Settings → Projects**. 2. Select the project. 3. Add Skills under **Auto attached skills**. Project settings are captured when a task is created. Changing the list affects new tasks, not existing conversations. ## Capabilities The Capabilities catalog groups example analyses by scientific area and outcome. Use it to discover a starting prompt, understand typical inputs and outputs, or open a new task for a supported workflow. Capabilities are examples, not rigid templates. After opening one, adapt the prompt to your experiment, files, organism, constraints, and desired output. ## Skills, resources, and tools | Use | Best choice | | ----------------------------------------------------- | --------------------------------------------- | | Follow a reusable, domain-specific workflow | **Skill** | | Start from an example research outcome | **Capability** | | Point Biomni at a database, package, or analysis tool | **Resource** | | Give the agent a file | **Upload** or select an existing project file | Databases, software, HPC tools, and pipelines. Add the context and constraints a workflow needs. # How to Prompt Source: https://docs.biomni.phylo.bio/how-to-prompt Give Biomni a clear scientific goal, the right inputs, and useful constraints You do not need to write a formal protocol before starting. A strong request makes the scientific goal and evidence boundary clear, then lets Biomni plan the implementation. ## Start with the outcome Say what you need to learn, decide, or deliver. ```text theme={null} Analyze my data. ``` ```text theme={null} Identify genes that differ between treatment and control in @counts.csv, then create a ranked result table and a publication-ready volcano plot. ``` ## Include the experimental context Add details that change the interpretation or method: * organism, reference build, assay, and tissue or cell type; * cohort definitions, controls, replicates, and batch structure; * units, column meanings, and missing-value conventions; * primary endpoint or research question; and * whether the work is exploratory, confirmatory, or intended for publication. ```text theme={null} These are paired tumor and adjacent-normal RNA-seq samples from 12 patients. Patient ID is the blocking variable in @metadata.csv. Use GRCh38 annotations and report both effect size and adjusted p-value. ``` ## Attach or mention the evidence Use **+ Add** for files, folders, cloud imports, Skills, resources, and connectors. Type `@` to search files and scientific resources, or `+` to search Skills. Do not rely on a filename alone when its structure is ambiguous. Explain which sheet, columns, groups, or identifiers matter. ## State constraints without over-specifying Specify a method when it is scientifically required. Otherwise, state the constraint and ask Biomni to choose and justify the method. ```text theme={null} Use a method appropriate for paired count data. Before running it, explain the design formula, filtering rule, and multiple-testing correction you chose. ``` Useful constraints include: * required or prohibited methods; * quality thresholds and inclusion criteria; * resource or runtime limits; * databases or date ranges to search; * output format, dimensions, and naming; and * citation or reproducibility requirements. ## Ask for inspectable outputs Request the artifacts needed to audit or continue the work: ```text theme={null} Return the full result table as CSV, the analysis notebook, SVG and PNG versions of each figure, and a short README describing inputs, software, parameters, and output files. ``` For literature or database research, ask for linked sources next to the claims they support. For data analysis, ask Biomni to separate observed results from interpretation. ## Use follow-up turns Keep related refinement in the same task so Biomni can use the conversation and generated files. ```text theme={null} The plot is correct, but label only the ten genes with the smallest adjusted p-values and increase the axis-label size. Do not rerun the statistical model. ``` If the goal changes substantially, start a new task. This keeps the evidence, assumptions, and results for each analysis easier to review. ## When you are unsure Ask Biomni to identify missing information before it acts: ```text theme={null} I want to test changes across three timepoints in this RNA-seq experiment. Read @metadata.csv and tell me what design details you still need before choosing a model. Do not run the analysis yet. ``` For high-impact conclusions, finish with an explicit verification request and run [Scientific Review](/features/scientific-review). # Introduction Source: https://docs.biomni.phylo.bio/introduction A research workspace where an AI agent can analyze data, run tools, and produce verifiable results Biomni Lab is an AI research workspace for biomedical and life-science work. You describe a goal in natural language; Biomni can inspect your files, search scientific sources, write and run code, use specialized tools, and return results in the same task. ## What you can do Biomni supports work such as: * literature and database research with linked sources; * statistical analysis and publication-ready visualization; * genomics, transcriptomics, single-cell, and multi-omics workflows; * protein structure prediction and molecular design; * custom Python, R, and shell-based analysis; and * larger CPU, high-memory, GPU, or pipeline workloads. The exact resources, models, and integrations available depend on your plan and workspace configuration. ## How work is organized Group related tasks and files around a research question or dataset. Keep one analysis or research thread in a focused conversation. Attach reusable, domain-specific workflows to a request. Preview, download, and continue working with generated files. Every account starts with a **Quick Tasks** project for one-off work. Create additional projects when tasks should share files, context, instructions, or collaborators. ## What happens after you send a request Biomni can plan the work, start an isolated cloud workspace when computation is needed, and show its tool activity as the task progresses. Generated artifacts appear in the conversation and Results panel. Long-running compute can continue as background work and report back to the same task. Biomni is an assistant, not an authority. Inspect source material, parameters, generated files, and important conclusions. For high-stakes work, use [Scientific Review](/features/scientific-review) and independent expert review. ## Start here Run a first task and work with its output. Give Biomni the context and constraints it needs. Start from a reusable scientific workflow. Choose a model profile and understand execution. # Pricing FAQ Source: https://docs.biomni.phylo.bio/pricing-faq Frequently asked questions about Biomni Lab pricing, plans, and billing ## What does Phylo cost? Phylo offers an Individual Free plan at no cost, an Individual Pro plan at \$100/month, and a Team plan at \$100/month per standard seat. Researchers at eligible academic or research institutions receive 50% off eligible paid plans, paying \$50/month for Individual Pro or \$50/month per academic Team seat. Monthly and annual billing are both available for paid plans; annual plans are billed once per year. ## What counts as "usage" and what does "10x daily usage" mean? Usage is based on the underlying LLM and compute resources consumed by your requests — not a simple message count. The actual usage per request varies highly depending on task complexity; a quick Q\&A uses far less than a multi-step data analysis. Pro users get 10x the daily usage allowance of Free users. You can check your current daily usage on the [Settings](https://biomni.phylo.bio/settings) page. ## Individual Free & Pro Plan ### What’s the difference between Individual Free and Pro? The Individual Free plan has no monthly subscription fee and includes a lower daily usage allowance. The Individual Pro plan costs \$100/month, or \$50/month with the academic discount, and includes a higher daily usage allowance and higher concurrent task limits. ### How does the academic discount work? The 50% academic discount is automatically applied based on your email address. If you sign up with a university or recognized research institute email, you'll be charged \$50/month instead of \$100/month for Pro. No coupon code or manual application needed. ### Which institutions qualify for the academic discount? We support 10,000+ universities across 200+ countries, plus select non-university research institutes. Eligibility is determined automatically against our supported institution list, which covers common academic domains like `.edu`, `.ac.uk`, `.edu.au`, and many more. ### How do I know if the academic discount is applied to my account? Go to [Settings](https://biomni.phylo.bio/settings) and start the upgrade flow — the price shown will reflect the academic discount (\$50/month instead of \$100/month) if your email qualifies. No payment is charged until you explicitly confirm. ### My university or institution is not recognized. What should I do? Our list covers 10,000+ universities worldwide and should be comprehensive for most researchers. If your institution is not covered, please reach out to us at [billing@phylo.bio](mailto:billing@phylo.bio) and we will try to add new universities and institutions based on availability. ### How do I upgrade to Pro? Go to [Settings](https://biomni.phylo.bio/settings), click "Upgrade to Pro," and enter your payment details via Stripe. We accept all major credit cards. Your Pro plan activates immediately after payment. ### How do I update my payment method? Go to your [Settings](https://biomni.phylo.bio/settings) page → Billing tab → Payment method item, then click the View button. From there, you can click Update to update your credit card. ### How do I cancel my Pro subscription? You can downgrade from [Settings](https://biomni.phylo.bio/settings) at any time. Your Pro access continues until the end of your current billing period, then you'll move to the Free plan. No penalties or cancellation fees. ### What happens when I hit my daily usage limit? Your tasks are queued until your usage resets the next day. Pro users have 10x the daily allowance and higher concurrent task limits, so they hit the limit far less often. ### Can I get a refund if I cancel my Pro subscription? Pro subscription fees are non-refundable for the current billing period. When you cancel, your Pro access continues until the end of the period you already paid for, and you will not be charged again. For details, see our [Terms of Service](https://phylo.bio/terms-03.18.26). ### Is my payment information secure? Yes. Phylo does not store your card number. All payment processing is handled by Stripe, and your card details never touch our servers. ## Team Plan ### What does the Team plan include? The Team plan is billed per workspace and gives each member Pro-level access in that shared workspace. Pricing is \$100/month per standard seat and \$50/month per academic seat. ### Do team members get their own usage limits? Yes. Usage limits are enforced per user, not pooled across the workspace. Team members currently get the same daily allowance as Individual Pro users. ### How does academic pricing work? Academic pricing is determined per member based on that member’s email address. This means one team can have a mix of standard seats at \$100/month and academic seats at \$50/month at the same time. ### When am I charged for seats? Team billing follows a recurring cycle anchored to the date the team subscription starts. Teams can be billed **monthly** or **annually**. At each renewal you are charged for the current number of seats for the upcoming period — the next month on monthly billing, or the next year on annual billing. When you add a member during the billing cycle, that seat is prorated for the remainder of the cycle. When that prorated charge is collected depends on your plan: * **Monthly teams:** the prorated amount is added to your next monthly invoice. * **Annual teams:** the prorated amount is billed at the time the member joins, as a separate charge covering the rest of your annual term — rather than waiting until your annual renewal. ### When does adding a member increase my bill? Adding a member increases billing when that member actually joins the workspace, not when you send the invitation. On monthly billing the prorated charge appears on your next invoice; on annual billing it is charged at the time the member joins. If you have already removed someone earlier in the same billing cycle and are simply filling that slot back to the same peak seat count, there is usually no additional seat-change charge. ### What happens when I remove a member? Removing a member revokes their access immediately. It does not create a prorated refund or credit for the current billing cycle — your team keeps that seat for the rest of the period you already paid for, and the lower seat count is reflected at your next renewal. On annual billing this means a removed seat is not credited for the remainder of the year, and the reduced seat count takes effect at your annual renewal. ### If I swap one member for another in the same cycle, do I pay extra? Usually no. Our billing uses a high-watermark model for mid-cycle seat changes, on both monthly and annual plans. If your team already reached a given seat count earlier in the cycle, removing one member and adding another back to that same count generally does not create an extra charge. Additional prorated charges only happen when the team exceeds its previous peak seat count in that billing cycle. On annual plans this free-swap window covers your entire annual term, not just a single month. ### Can you show me an example invoice for team seat changes? Yes. Here is an example using our current Team pricing and billing behavior for standard seats: * A team starts its billing cycle with **3 standard seats** * Standard seats cost **\$100/seat/month** * On day 10 of the cycle, the team adds **1 member**, bringing the team to **4 seats** * On day 15, the team removes **1 member**, bringing the team back to **3 seats** * On day 20, the team adds **1 member**, bringing the team back to **4 seats** * On day 25, the team adds **1 more member**, bringing the team to **5 seats** On the next invoice, the team would be charged for: * **5 seats for the new month** = `5 × $100 = $500` * **1 prorated seat from day 10 to the end of the cycle** = about `21/30 × $100 = $70` * **1 additional prorated seat from day 25 to the end of the cycle** = about `6/30 × $100 = $20` **Total: about \$590** In practical terms, if someone leaves your team and you later replace them during the same billing cycle, you generally will not be charged again just for returning to the same seat count. You would only see an additional prorated charge if your team grows beyond the highest number of seats you already reached in that cycle. **On annual billing, the same high-watermark logic applies — only the timing changes.** Your seats are billed up front for the year, and any seat addition above your previous peak is billed at the time the member joins (a prorated charge covering the rest of your annual term), rather than waiting for your annual renewal. Removing and re-adding members below your peak remains free for the entire year. ## Invoices & Billing Details ### Can invoices be made out to my university or company? Yes. When you upgrade, you are asked for the billing name and address that should appear on your invoices — this can be your institution or employer rather than you personally. This is what invoices render as "Bill to." ### Can I add a VAT or tax ID to my invoices? Yes, outside the US. During checkout you can choose to purchase as a business and enter your VAT number or local equivalent, and it will appear on your invoices. Stripe only offers the business tax ID field for countries that have one, so it is not shown for US billing addresses. Your address and tax ID appear on the invoice PDF. The online invoice page shows only the billing name, so download the PDF if you are checking the full details. ### How do I change my billing address or tax ID after upgrading? Go to [Settings](https://biomni.phylo.bio/settings) → Billing → **Billing details**, then click **Update billing details**. This opens the Stripe billing portal, where you can change the billing name, address and tax ID. No support request is needed. On a Team plan, only workspace admins and owners can view or change billing details. Other members do not see them at all — ask an admin on your workspace. ### Can you correct an invoice I have already received? No. Changes apply to invoices issued from that point on — Stripe copies your details onto an invoice when it is issued, so an invoice that already exists keeps what it was issued with and cannot be reissued. Set your billing name, address and tax ID before your next invoice is due. ### Can I change the email address invoices are sent to? Yes. The same **Update billing details** button lets you change the billing email, which is useful for sending invoices to accounts payable rather than to whoever signed up. This is separate from the email you log in with, and changing your login email will not overwrite it. # Quickstart Source: https://docs.biomni.phylo.bio/quickstart Create a task, add your data, and work with Biomni's results This guide takes you from a blank task to a result you can inspect and refine. ## 1. Choose where the work belongs Use **Quick Tasks** for a one-off question. For an ongoing experiment or dataset, create a project so its tasks can share files and project context. To create a project, open the project selector in the sidebar and select **Create a new project**. Give it a clear name; you can add context, instructions, and auto attached Skills later under **Settings → Projects**. ## 2. Create a task Open the project and create a new task. A task is one conversation with Biomni. Keep a task focused on one analysis thread so its files, decisions, and follow-up requests remain easy to understand. If the model selector is available, **Standard** is the default for everyday work. See [Models & Compute](/features/models-and-compute) before choosing Fast, Max, or a custom model. ## 3. Add files, resources, and Skills Select **+ Add** beside the composer to open the current attachment menu: * **Upload files** or **Upload folder** adds local data. * **Select from uploaded files** attaches an existing project file. * **Import from cloud storage** copies supported external files into the project when that feature is enabled. * **Resources** opens databases, scientific tools, and software. You can also type `@` to search resources and files. * **Skills** opens reusable workflows. You can also type `+` to search Skills. * **Connectors** exposes connected external services when your organization has enabled them. Selected files, Skills, and resources appear directly in the message so you can confirm the task has the right context before sending. For a folder with many related files, upload the folder or a ZIP instead of attaching files one by one. A single message can attach up to 100 files. ## 4. Write the request Include four things: 1. **Goal** — the decision, analysis, or artifact you need. 2. **Inputs** — filenames, cohorts, organisms, conditions, or sources. 3. **Constraints** — required method, reference build, thresholds, or exclusions. 4. **Output** — the files, figures, tables, or explanation you expect. ```text theme={null} Compare treatment and control in @counts.csv using the sample labels in @metadata.csv. Run differential expression with an adjusted p-value cutoff of 0.05. Return a CSV of all results, a labeled volcano plot, and a short methods summary that states every filtering decision. ``` See [How to Prompt](/how-to-prompt) for more patterns. ## 5. Follow the work After you send the message, the task shows the agent's progress and tool activity. Expand trace sections when you need to inspect commands, tool inputs, or outputs. Depending on the work, the task can also show: * a **Plan** for multi-step execution; * **Results** generated during the task; * **Compute** or HPC activity that continues in the background; and * **Notes** associated with the task. You can leave a long-running task and work elsewhere. Return from the project sidebar to check its current status. ## 6. Inspect the result Generated files appear as artifacts in the conversation and in **Results**. Open a supported file to preview it, or download it for local inspection. Keep the analysis in the same task when asking Biomni to revise an existing result: ```text theme={null} Regenerate the volcano plot with larger labels and annotate the ten genes with the smallest adjusted p-values. Keep the underlying result table unchanged. ``` ## 7. Verify important work * Open citations and confirm that they support the nearby claim. * Inspect generated tables, notebooks, plots, and reports. * Ask Biomni to state assumptions, exclusions, software versions, and parameters. * Run [Scientific Review](/features/scientific-review) on a completed answer. * Independently validate results used for clinical, regulatory, or publication decisions. ## Next steps Organize tasks, files, and project settings. Attach a reusable scientific workflow. Import external files from a connected source or public link. Contact the team or open the in-product help menu. # Report a Bug Source: https://docs.biomni.phylo.bio/support/bug-reporting Send the details the Biomni team needs to investigate a product issue For self-serve Biomni Lab, the fastest reporting flow is built into the product: 1. Select **Help** in the sidebar. 2. Choose **Report a Bug**. 3. Describe the problem and submit the report. If **Report a Bug** is not present, use **Live Chat** or email support. ## What to include * what you were trying to do; * what happened and what you expected instead; * steps that reproduce the issue; * the affected task or project; * the approximate time and your time zone; * the browser or client you were using; and * a screenshot or screen recording when it helps explain the behavior. For an incorrect scientific result, also identify the input file, disputed claim or output, and the evidence you expected Biomni to use. ## Protect sensitive information Do not paste passwords, API keys, access tokens, private keys, or credentials into a report. Avoid adding regulated or sensitive source data unless the approved support process for your organization explicitly permits it. ## Other support channels Live Chat, email, and workspace-specific support. Discuss product usage with other researchers. # Customer Support Source: https://docs.biomni.phylo.bio/support/customer-support Get product, account, billing, or technical help Select **Help** in the Biomni Lab sidebar to see the support options available for your workspace. ## Live Chat Choose **Help → Live Chat** for product and technical questions. Include the affected task, the approximate time of the issue, and what you expected to happen. ## Email [support@phylo.bio](mailto:support@phylo.bio) Email is useful for account, billing, access, and longer support requests. Do not send passwords, API keys, tokens, or private keys. ## Community Slack The public Biomni Lab community is available on self-serve workspaces through **Help → Join Slack**. Ask usage questions and learn from other researchers. ## Before contacting support 1. Check the task status and expand the relevant error or tool trace. 2. Retry only if doing so cannot duplicate an external write or expensive job. 3. Record the task, time, client, and steps that led to the problem. 4. Use [Report a Bug](/support/bug-reporting) for reproducible product defects. We can help with account setup, product usage, unexpected behavior, analysis workflow questions, billing, and workspace administration.