Aon scales clx: Classify Patterns and Test Your Rule

You identify a neat pattern in the first grid, select two similar-looking answers, and discover that your rule never explained the second example. That is the characteristic preparation mistake for Aon scales clx: matching appearances before testing the classification rule.

The task is not to find one strange object. It is to infer what two example grids have in common, then select the candidate grids that follow that rule. Your preparation should therefore produce a testable sentence and a reason for accepting or rejecting each option, not a collection of remembered pictures.

This guide uses Aon's current public candidate materials and original exercises. For the different nine-object exception task, see Aon scales ix.

Confirm that your invitation actually says scales clx

Aon's current preparation page identifies scales clx as an inductive-logical reasoning assessment with a six-minute limit. It tells candidates to complete as many tasks as possible. It does not publish a fixed task count for this format. Use your invitation and the instructions shown in your assessment as the operational authority. Aon candidate preparation

The official practice PDF shows two example grids and four candidate grids; exactly two candidates follow the same rule as the examples. Its instructions allow selection and deselection before proceeding. Those details matter: finding one valid candidate is not the finished response. Aon scales clx practice PDF

Do not transfer a question count, scoring rule, or guessing strategy from another Aon assessment. In particular, scales ix uses a different decision: identify one exception among nine objects. The two formats both involve patterns, but the evidence you must produce is different.

The public offline examples are untimed practice. Their purpose is to learn the interface and rule-testing task, not to establish an employer's cutoff, percentile requirement, or likelihood of receiving an offer.

Start with a rule that explains both examples

Scan the two grids for symbol counts, repetitions, rows, columns, positions, and relationships. Ask what survives the differences between them. A distinctive position in one example is only a hypothesis until it also explains the other.

State the proposed rule in one sentence: “Each row contains exactly one circle,” for instance. Then apply it mechanically to the second example. If it fails, reject or refine the hypothesis before inspecting the candidate answers more deeply.

This order prevents answer-driven overfitting. If you first decide that options A and C look right, you can invent a complicated rule tailored to those choices. The two examples should constrain the rule before the choices tempt you into a story.

Different kinds of rules require different checks. A count rule ignores position. A row rule checks each row independently. A symmetry rule compares corresponding positions. Naming the rule family keeps you from switching criteria halfway through a candidate because one part looks inconvenient.

Original exercise: reject a tempting column rule

Let C mean a circle and T mean a triangle. Treat these as symbols, not initials with numerical values. The two example grids are:

Example 1       Example 2
C T T           T C T
T C T           C T T
T T C           T C T

Example 1 makes “one circle in each column” look promising. But Example 2 has circle counts of one, two, and zero across its columns. That hypothesis fails the second example.

The rule “each row contains exactly one circle and two triangles” explains both examples. The circle may move within a row, and the same column may contain more than one circle. Now classify all four candidates:

A               B
T T C           C C T
C T T           T T T
T C T           T C T

C               D
T C T           C T T
T T C           C T T
C T T           T T T

A and C satisfy the rule. B violates it in rows one and two. D violates it in row three. The final selection is A and C, not simply the two grids that have an attractive diagonal.

Notice that B still contains three circles in total. A global count alone would accept it incorrectly. The placement requirement is doing real work: one circle in every row, not three circles anywhere.

Candidate	Test against the stated row rule
A	Pass: all three rows have one circle.
B	Fail: the first row has two circles and the second has none.
C	Pass: all three rows have one circle.
D	Fail: the third row has no circle.

This four-row record is an answer key and a debugging asset. If you selected B, your error was likely a weakened rule, not an inability to recognize circles.

Original exercise: when position is a distraction

Now use X and O, and consider a different pair of examples:

Example 1       Example 2
X X O           O X X
O X O           X O X
X O X           O X O

Both examples contain exactly five X symbols and four O symbols. The rows and corner arrangements differ, so test a count hypothesis rather than assuming a fixed positional template.

A               B
X O X           X O X
O X X           O X O
O X O           O X O

C               D
O X O           X X O
X X O           X O X
X O X           O X X

Under the proposed rule, A and C pass: each has five X symbols. B has four, and D has six. These are original practice grids for this specific counting exercise, not a claim that every real clx item uses counts or that a finite pair of examples mathematically determines only one possible rule.

Explain the contrast with the first exercise. There, three circles globally were insufficient because the rule constrained each row. Here, the hypothesis is deliberately global. You cannot keep applying the previous row check just because it worked once.

If you want to test the exercise in code, make the rule explicit rather than encoding the answer letters:

def follows_count_rule(rows):
    return sum(row.count("X") for row in rows) == 5

candidates = {
    "A": ["XOX", "OXX", "OXO"],
    "B": ["XOX", "OXO", "OXO"],
    "C": ["OXO", "XXO", "XOX"],
    "D": ["XXO", "XOX", "OXX"],
}
assert [key for key, rows in candidates.items()
        if follows_count_rule(rows)] == ["A", "C"]

Code is a preparation check, not a tool to use during a restricted assessment. Its value is exposing whether your verbal rule and your answer key actually agree.

Use counterexamples to improve your rule

After solving an untimed item, create the smallest change that should flip its classification. In the row exercise, move one circle from one row into another. The total remains three, but the grid should fail. That is a counterexample to the overly broad total-count rule.

In the count exercise, rearrange symbols without changing the number of X symbols. The grid should still pass. If your explanation now rejects it, you have smuggled an unnecessary positional condition into the rule.

These paired changes separate essential conditions from coincidences. Write both outcomes: a minimally changed negative example and a differently arranged positive example. A rule that cannot predict those outcomes is not yet a useful preparation takeaway.

Avoid making the exercise artificially ambiguous and then blaming yourself for not finding “the” answer. Arbitrary invented grids can support many relationships. Keep practice examples simple enough that you can specify and verify the intended rule. Use Aon's public examples for interface familiarity, and original examples for testing your explanation process.

Practice speed without importing the wrong timing model

Six minutes is the documented overall limit, not a published fixed number of seconds per item. Because the current public clx description does not provide a fixed task count, dividing six minutes by a count borrowed from another test creates a false target.

First build untimed accuracy: rule, evidence from example one, evidence from example two, and classifications for all four options. Then run short timed sets and record correct completed decisions, not simply clicks or grids viewed.

Notice where time disappears. Are you repeatedly counting the same symbols? Switching among hypotheses without checking either example? Finding one valid answer and forgetting to search for the second? Those are different bottlenecks and need different practice.

During preparation, a consistent scan can reduce unnecessary work: compare totals, inspect row/column relationships, then test positional relationships if the earlier hypotheses fail. This is a proposed practice method, not an Aon-prescribed solution algorithm or a guarantee that simpler counts always come first.

Follow the actual assessment's controls and instructions for advancing, revisiting, and recording responses. Do not assume a navigation feature from an offline PDF or another scales format exists in your live invitation.

Diagnose mistakes by the stage that failed

Keep a compact error record with the proposed rule, the first contradiction, and the repair. “Pattern question wrong” is too vague to change the next attempt.

A perception error means you missed a symbol or position. Repair it with a repeatable scanning order and careful recounting in untimed practice. A hypothesis error means your rule explained only one example. Repair it by checking the second example before touching the options.

A classification error means the rule was sound but you applied it inconsistently. Use a candidate-by-candidate pass/fail record. A response error means you identified both valid options but recorded only one or left an accidental extra selection. Rehearse the interface check separately from the reasoning.

You may have more than one error in an item. Record the earliest failure first, because fixing a downstream click does not repair an incorrect hypothesis. Over several attempts, compare the distribution of error types rather than relying on a single overall percentage.

Do not interpret an improvement in your homemade practice score as a validated percentile on the live assessment. The exercises, timing, difficulty, and scoring population are different.

Five broader questions for classification and reasoning

These links let you practice explicit constraints, candidate rejection, and decisions under time pressure. The coding tasks require implementation work beyond clx; use them to strengthen the underlying habits, not to mimic Aon's interface.

Practice question	Evidence to produce
Find the Top-Left Submatrix Matching a Grid Pattern With Letter Variables	Separate the matching rule from the location of a candidate.
Find Repeated-Value Patterns in a Matrix	State what repetition means and test grids that nearly satisfy it.
Optimize attempts in a timed logic test	Discuss pacing only after identifying the actual scoring assumptions.
Deduce position from logic clues	Reject a tempting arrangement using one concrete contradiction.
Solve two logic brain teasers	Explain why a conclusion follows instead of reporting only an answer.

Your readiness check is a classification, not a hunch

Before adding more timed volume, see whether you can explain both examples with the same concise rule, identify exactly two passing candidates, and give a specific rejection reason for the other two. Then alter an irrelevant feature and confirm your decision survives.

If those steps fail, return to untimed rule testing. If they pass but time is lost, target the scan or response bottleneck shown in your error record. That is more informative than collecting another page of unexplained answers.

For clx, the useful habit is simple: both examples first, every candidate second, response check last.

Sources and Further Reading

• Aon: prepare for your online assessment
• Aon: scales clx official practice tasks
• Aon: talent and rewards assessment context

Sources checked October 4, 2026. All worked grids and error-diagnosis exercises in this article are original.