Sequences in Venus: The Logic Underneath Every Pipetting Step

The sequence is the map

Every pipetting step in a Venus method, aspirate, dispense, tip pickup, tip eject, requires a sequence. You can't tell the robot "go to well B3." You tell it "advance to the next position in this sequence," and the sequence determines where that is. Sequences are the bridge between your method logic and the physical positions on the worktable.

Understanding sequences at more than a surface level is the single biggest step a Venus user can take from following examples to writing methods deliberately. Everything in this article builds directly toward the variables and loops covered later in the series.

What a sequence contains

A sequence is an ordered list of position references. Each entry in the list specifies:

• Which labware the position belongs to
• Which position within that labware (e.g., well A1, well B1, etc.)
• The index of that position in the sequence (first, second, third...)

The sequence also maintains a current position pointer, the index of the next position that will be used when a step references this sequence. The pointer starts at 1 (the first position in the sequence) and advances based on how the step is configured.

Sequence counting: Automatic vs Manual

Every step that uses a sequence has a Sequence counting parameter with two options.

Automatic (1): after the step uses a position, the pointer advances to the next position in the sequence. The next time this step (or any step using the same sequence) runs, it will use the next position. This is the standard mode for working through a series of wells in order.

Manual (0): the pointer doesn't advance. The same position is used every time. Use this when you want to aspirate repeatedly from the same location; for example, drawing repeatedly from a single trough position across multiple transfers.

This seems simple, but sequence counting is the source of a large proportion of Venus method logic bugs. The classic error: a method that processes 96 wells correctly the first time, then starts at well 97 (which doesn't exist) on the second run, because the sequence pointer was never reset between runs.

Sequence pointer management

The pointer doesn't reset automatically at the start of a new run unless you explicitly reset it in the method. For production methods that will be run repeatedly, managing the pointer state is essential.

Venus provides four General Steps for sequence manipulation:

Sequence: Get Current Position reads the current pointer index into a variable. Use this when you need to know which position the sequence is currently at, for example to branch logic based on how far through a plate you are.

Sequence: Set Current Position manually sets the pointer to a specified index. Use this to reset a sequence back to position 1 at the start of each run, or to jump to a specific position in the middle of a workflow.

Sequence: Get End Position reads the total number of positions in the sequence. Use this in loop conditions to know when you've processed all positions.

Sequence: Set End Position sets the end position of the sequence, effectively truncating it to a subset of its total positions. This is useful for variable-sample-count methods: if you have a 96-position plate sequence but only 32 samples to process, set the end position to 32 and the method processes exactly 32 positions before stopping.

The Adjust Sequences step modifies multiple sequences simultaneously, shifting their start and end positions by a defined amount. This is used in more complex methods where you need to offset multiple sequences in coordination, for example moving through a plate in column blocks rather than individual wells.

Sequence ordering and multi-channel pipetting

The order in which positions appear in a sequence determines the physical order in which the robot addresses them. For single-channel operations, this is straightforward. For multi-channel operations with the 8-channel pipetting head, position order has a direct consequence on whether the multi-channel transfer is physically possible.

Column-wise vs row-wise ordering

The 8 channels of the Hamilton STAR pipetting head are arranged vertically in a single column, corresponding to the 8 rows of a standard 96-well plate (rows A through H). When all 8 channels aspirate from a sequence simultaneously, they access 8 consecutive vertical positions, one per row in the same column.

A column-wise sequence for a 96-well plate orders positions as: A1, B1, C1, D1, E1, F1, G1, H1, A2, B2, C2 ... H12. An 8-channel aspiration from this sequence uses positions 1 to 8 (column 1, all rows) simultaneously, then positions 9 to 16 (column 2, all rows), and so on. Twelve aspiration steps process the entire plate.

A row-wise sequence orders positions as: A1, A2, A3 ... A12, B1, B2 ... H12. An 8-channel aspiration from a row-wise sequence using the first 8 positions would address A1, A2, A3, A4, A5, A6, A7, A8, eight wells in the same row with one per channel. This works, but only if the channel pattern allows for it and the step is configured to match.

Use column-wise ordering for most 8-channel operations. It matches the natural movement pattern of the 8-channel head and produces the most efficient transfer sequences.

Custom sequence ordering

For methods that don't process wells in simple column or row order, such as cherry-picking specific wells, processing a predefined sample map, or running a reformatting workflow, custom sequences can be created in the Deck Layout Editor by manually clicking wells in the desired processing order.

Custom sequences can also be created and modified at runtime using Sequence: Set Current Position and Sequence: Set End Position in combination with variables. This is covered in the variables and loops article.

One sequence vs multiple sequences

A common design question when building a worktable: should you define one sequence covering the entire plate, or multiple sequences covering subsets?

Single sequence is simpler to define and manage. The sequence pointer advances through all positions automatically. Use Sequence: Set End Position at runtime to limit processing to a specific number of positions. This is the best default for homogeneous workflows that always process the same type of transfer across the plate.

Multiple sequences are appropriate when different subsets of the plate need to be treated differently. For example: columns 1 to 6 receive one reagent from sequence A; columns 7 to 12 receive a different reagent from sequence B. Defining two separate sequences allows you to reference each independently in the method steps, with independent pointers and independent end positions.

Whether you use one or many sequences, always name them descriptively in the Deck Layout Editor. A sequence named SamplePlate1_Columns1to12 is easier to trace through a method than a default name like Sequence_1. This matters when the method is handed to another operator or revisited six months later.

Tip sequences and tip counting

Tip sequences work by the same pointer logic as plate and trough sequences, with one important addition: tip counting.

When a tip sequence has tip counting enabled (in the Load step or tip carrier definition), Venus tracks how many tips have been used and prevents the method from attempting to pick up from an empty tip position. This is particularly important for long methods that process more samples than a single tip rack holds. The method needs to know when to expect the operator to reload tips, or to load a fresh tip rack automatically via the Autoload system.

Tip sequences should always be defined to match the physical arrangement of tips on the carrier. If tips are loaded from position 1 (front-left of the carrier) forward, the sequence should start at position 1 and advance forward. If tips are loaded in a specific partial pattern, define the sequence to match that pattern exactly. Don't use a full-rack sequence if only half the rack is loaded.

The channel pattern and tip pickup

When a tip pickup step runs with an 8-channel head, the channel pattern determines which channels pick up tips. The channel pattern is a string of 8 characters, each 1 (channel active) or 0 (channel inactive). 11111111 picks up on all 8 channels. 10000000 picks up on channel 1 only. 11110000 picks up on channels 1 to 4.

The channel pattern doesn't automatically filter the sequence. If you pick up tips on 4 channels but the sequence advances by 8 positions, your tip sequence pointer will be 4 positions ahead of where your tips are. Set the channel pattern consistently with the sequence counting behaviour to avoid pointer drift. Channel pattern selection and step tiers are covered in detail in the next article.

Sequences across multiple labware

A single sequence can span multiple labware items. A sequence named AllSamplePlates could contain all 96 wells from plate 1 followed by all 96 wells from plate 2, giving a 192-position sequence that the method works through without needing separate steps for each plate.

This is useful for batch processing workflows. Set Sequence: Set End Position to the number of samples at runtime and the same method handles any batch size from 1 to 192 without modification.

The alternative is to define a separate sequence per plate and loop through them explicitly. Both approaches work. The single cross-labware sequence is simpler for linear batch workflows; the per-plate sequences are clearer for workflows where each plate is processed differently.

Debugging sequence problems

When a method produces unexpected behaviour, wrong positions, skipped wells, asymmetric processing, sequence pointer state is almost always worth investigating first.

Is the pointer where you think it is? Add a User Output step before the problematic pipetting step, displaying the current sequence position (Sequence: Get Current Position into a variable, then display that variable). This reveals pointer state at runtime.

Is sequence counting set correctly? Open the aspirate or dispense step and verify whether Automatic or Manual counting is set. A step that should advance after each transfer but is set to Manual counting will repeat the same position indefinitely.

Were sequences reset between runs? If the method is run back-to-back, the pointer from the previous run may not have been reset. Add Sequence: Set Current Position to position 1 at the start of the method for any sequence that needs to begin fresh each run.

Does the sequence contain the expected number of positions? Add a User Output displaying Sequence: Get End Position. This confirms the sequence was defined correctly and hasn't been inadvertently truncated by a previous Sequence: Set End Position call.

With sequences covered, the next article looks at the step types that actually move liquid: Single Steps, Power Steps, and Smart Steps.