Architecture
This page explains how Bionamic connects the browser, application server, AI models and scientific tools, and how the system controls data access and execution.
System overview
Researchers use Bionamic in a web browser. The browser connects to an application server, which manages the workspace and coordinates sign-in, requests to AI models, and tool execution.
The application server manages shared files, accounts, permissions, conversations and agent runtimes. It checks whether each request is permitted and coordinates the services needed to carry it out.
During sign-in, the browser is redirected to the authentication server and returns to the application. The application server verifies the result with the authentication server, checks that the researcher has access to the instance, and remains responsible for permissions within the workspace.
The agent runtime sends conversation context through the model gateway to a configured inference server. The gateway controls permitted endpoints, routes requests, and records usage and costs against the instance’s budget. The model returns text or requests to use tools.
Tools perform actions and computations requested by researchers and agents: agent-written scripts run in sandboxes, and scientific jobs run on the compute service. Results can be saved in the workspace or included in the conversation.
Shared workspace and agents
Bionamic provides a shared file system for a team of researchers. The files can include workbooks, sequences, next-generation sequencing (NGS) data, protein structures (PDB, mmCIF), notes, and any other type of file. The workbook presents scientific data in a spreadsheet, the molecule viewer displays sequences and three-dimensional structures, and the Files app lets researchers browse and organize the shared files.
AI agents are optional. There are two types: personal assistants and channel agents. Both can explain data, read and modify files, edit workbooks, run scripts, and use scientific tools such as structure prediction, within the resources and permissions configured for them. Results saved in shared files can be used by the team, including when the work was requested in a private assistant conversation.
A personal assistant is a private agent for an individual researcher, and its conversation is private to the researcher’s account. When the researcher sends a request, the assistant receives context identifying the application and file they have open; for a workbook, this includes the sheet, the selection, and a reference to the saved revision. The entire workspace is not included in every model request. Background model calls summarize conversation content into a private index that helps the assistant find earlier work; these calls do not require a separate user request.
A channel is a shared conversation in which researchers and channel agents write posts and follow up together. When automatic listening is enabled, new posts and recent context are sent to the configured model so the agent can decide whether to respond, including when it is not mentioned.
The agent runtime
Bionamic operates its own agent runtime. It sends a request to the configured model and receives text for the conversation or requests to use tools. When the model requests a tool, the runtime executes the call and returns the result to the model. The cycle continues until the agent finishes its response or reaches a configured limit.
The runtime runs outside the environment where scripts and code written by the AI model are stored and executed. Provider credentials and API keys are kept outside that environment, so the model’s code cannot read them. Administrative information, such as account records and user lists, is reached only through the application’s authorized interfaces.
Executions have bounded resources and lifecycle controls. A tool or service failure is returned to the agent as a result to handle. A failed run does not undo work that was already saved, so the recorded actions and resulting files show what happened.
Inference providers and local models
Bionamic supports hosted inference, where model requests go to an external inference service, and local inference, where a model server runs on Bionamic-operated or customer infrastructure. The local model in Bionamic’s current registry is GPT-OSS 20B, running on Bionamic servers. The hosted models are:
| Model | Configured routing |
|---|---|
| Claude Haiku 5.5 | EU |
| Claude Sonnet 5.5 | EU |
| Claude Opus 5.5 | EU |
| Claude Opus 4.8 | EU |
| GPT-6 Luna | Global |
| GPT-6 Sol | Global |
| GPT-6 Astra | Global |
| DeepSeek V3.2 | EU |
| Kimi K3 | Global |
| Mistral Large 3 | US |
Together with each customer we choose the permitted models, inference providers, processing regions, and usage limits for their instance, based on their requirements for capability, cost, and data handling. Further models, local or hosted, are reviewed for compatibility, data access, retention and training use before they are enabled. The configuration can be changed without moving the shared files and conversations.
The model gateway checks requests against the endpoints permitted for the instance and applies its usage controls; a model cannot select an inference provider for itself. Bionamic authenticates requests to Amazon Bedrock with AWS API access keys, held outside the environment that executes the agent’s scripts and code.
The location of the inference service is separate from the location of the workspace and compute services: a workspace hosted by Bionamic can use a local model, and a customer-hosted workspace can use an external provider. Bedrock endpoints use EU, US or global routing, so the processing location is part of choosing an endpoint.
Model escalation and inference budgets
An instance can be configured with a smaller model and a stronger model. Runs begin with the smaller model, which completes suitable tasks or requests a handover when it needs more capability. The decision is made during the work, rather than by asking the user to select a model for each question.
On escalation, the stronger model receives the visible conversation, tool calls, and their results, together with the handover reason, and continues from that work. Provider-specific hidden reasoning is not transferred. This reduces the work done by the expensive model; it does not guarantee fewer tokens on every run, since a handover has its own context-processing cost.
Each instance has a monthly inference budget shared by its agents. The model gateway tracks usage and warns as the budget is approached. With a hard stop enabled, it refuses new inference requests once recorded spending reaches the limit. Requests already in progress can still incur costs, so this is not an exact cap on the provider’s bill.
The gate
The gate is the service boundary through which controlled workspace operations are performed. It associates requests with authenticated users or execution identities, validates the operation and its arguments, and applies ownership and access rules. An agent cannot give itself a different identity by putting one in a tool argument.
The gate records permitted and refused operations in an append-only, hash-chained access log, including the caller, requested action, target and decision. It also coordinates job submissions and tool installation requests, validating completion reports before updating workspace state. Direct reads and writes within a live database are not individually recorded as gate operations.
These checks enforce identity, structure, ownership, and state transitions. Like the other controls on this page, they do not establish that a model’s scientific interpretation is correct: software authorization and scientific validation solve different problems, and results still need to be judged from their methods, inputs, and evidence.
Scientific tools and compute jobs
Scientific tools execute defined computations, such as sequence annotation or structure prediction, and return outputs that can be examined independently of the agent’s explanation. The OAS and SAbDab search tools query local database snapshots on Bionamic’s servers, so search sequences are not sent to those database providers; an agent’s model requests may still include the sequence or results.
Computations are submitted with defined inputs and a selected tool. The compute service schedules them and reports status and outputs. Job records link each computation to its originating request, its inputs, and its results. Because job state is kept outside the model call, Bionamic can follow a long computation and resume the associated work when the result is available. Failures and cancellations are recorded as such; a model’s statement that a tool ran is not a substitute for the job record.
The toolsmith and custom tools
When a task needs a capability that is not available, an agent can submit a tool request. The toolsmith builds a reusable tool from a description of the capability, its input and output contract, and its software requirements. It runs as an installation workflow on the compute service, with its own model access, and is not given the customer workspace. Requests are screened before entering the workflow, and development and checks use synthetic or public fixtures rather than customer research files.
The installation produces a versioned candidate and verification records. The gate checks the candidate’s ownership, revision, contract, environment identity, and verification evidence before registration and activation; the toolsmith cannot authorize its own candidate. Installation and activation can be automatic under the configured policy, without bypassing these checks. Once activated, the tool runs as a compute job with the relevant execution limits, and replacement and withdrawal go through the same registration.
The checks show that the packaged tool meets its technical contract and passes its test cases. They are not a software security audit or proof that a method suits every dataset, so newly introduced methods should be reviewed according to the decisions they support.
Sandboxes and network boundaries
Agent-written code runs inside Linux sandboxes using namespaces, restricted filesystem mounts, dropped privileges and resource limits. System-call filtering restricts process inspection, and runs cannot acquire additional privileges. Provider credentials remain outside the sandbox.
Interactive agent execution and scientific compute jobs have separate environments. GPU work is submitted as a computation; the conversational agent has no direct access to the host’s GPU devices.
Agents can access public internet resources. The network boundary blocks the host, private and cloud-metadata networks. A host-side logger records outbound connections and refused attempts; a logger outage does not stop traffic. Toolsmith installations download packages through the compute service’s egress proxy. Hosted inference and email delivery are the other external services. External documents and tool results are still untrusted input to the agent.
Identity and access
Bionamic signs users in with passkeys or emailed sign-in links and does not store passwords. Team administration controls membership and application access. Single Sign-On and IP restrictions are available on request.
User requests and agent runs have their own identities, and the gate applies ownership and access checks to both. An agent works only through the resources made available to its run; it does not gain administrator access because a user asks it to perform an action.
Customer isolation and data protection
Each customer has a separate application environment. Customers may share physical hardware; a dedicated machine is available on request.
Browser communication uses encrypted transport. Encryption at rest is available and is confirmed for each deployment, together with key management and backup arrangements.
Versioned workspace files use revision checks that preserve history and detect conflicting changes. Live files, such as SQLite databases and FASTQ files, are written in place without automatic revision history. Databases use SQLite’s own locking; recovery of live files relies on the captured backups described below.
Researchers see shared data according to their application access, and personal assistant conversations belong to individual accounts. Infrastructure operators may have administrative access to stored data and operational records.
Backups and recovery
Bionamic’s hosted backup system is configured to capture workspace data hourly and copy completed snapshots to a separate backup server over encrypted SSH. The backup server pulls through restricted, read-only access; the application server holds no credential for deleting remote backups. Account and passkey records are also backed up, excluding signing keys and temporary sign-in state.
Database snapshots are consistent, and live files are captured separately. Files still being uploaded may be incomplete or skipped. Copies are verified before being accepted, and recovery uses the latest successfully completed backup. Restore tests are scheduled weekly, rotating through instances, with monthly integrity audits.
Retention keeps recent hourly copies and daily, weekly and monthly recovery points, with monthly points for about six months. Backup location, retention and encryption at rest are confirmed for each deployment. Backup retention is separate from model-provider retention; deleted workspace data may remain in retained backups.
Model data access and retention
A model request can contain the researcher’s messages, relevant conversation history, file contents read by the agent, and tool results. The entire file system is not sent on every turn, but content retrieved during a task may become part of later requests.
Local models run on Bionamic servers or customers’ own servers, and their requests are not sent to an external provider. Bionamic’s current local inference endpoint retains no requests.
Amazon Bedrock runs hosted models through AWS’s inference service. According to AWS, model developers cannot access customer prompts or responses through Bedrock, and neither AWS nor the model developers use this data to train their models (AWS’s explanation of model data use). Training use, retention, and human access are separate questions: Bedrock retention depends on the model, API behavior, and account settings, and some models require retention and may permit AWS review for abuse prevention (AWS’s data-retention documentation). We review these settings with the customer when configuring an instance, including any requirement for zero data retention.
Inference retention is separate from Bionamic’s own. The workspace keeps files, revisions, conversations, and execution records so that work can be continued and reviewed; these can contain research content. The model gateway’s usage ledger records metadata and costs, not prompt content. A provider’s zero-retention policy therefore does not mean that Bionamic deletes the conversation or its results.
Deployment and data location
Bionamic-operated application servers are hosted on UpCloud. Bionamic can also be deployed with a customer’s preferred cloud provider or installed on customer Linux infrastructure. The arrangement determines which party operates the application, storage, compute resources, and supporting services.
Workspace storage, backups, inference endpoints, and compute services can each have their own location, so a deployment review establishes each of them, together with the external connections the intended workflows need. A single location label for the application does not describe all of these flows.
Traceability and security review
The system retains conversation messages, execution records, gate access logs, model handovers, file revisions where supported, computation inputs and outputs, and tool registration records. Execution records document what an agent run did; gate access logs document authorization decisions. Together they establish what was requested, what ran, and which artifacts were produced. Not all of these records are shown in the application, and administrators and Bionamic’s operators can see records that workspace members cannot.
We welcome technical questions about a proposed or existing deployment. A review covers identity and access, customer isolation, data locations, provider terms, network connections, tool installation policy, operational records and their retention, backup and restoration, update responsibilities, incident contacts, and, for personal data, the relevant roles and contractual terms. The website privacy policy covers this public website only. Contact info@bionamic.io to discuss architecture, deployment, or security requirements.