Satirical AI Code-Review Puzzle Sim

Agents! Please? Wiki

Review AI-written code, interrogate coworkers, test suspicious inputs, fix or approve tickets, take daily gigs, and face consequences shaped by your choices.

Agents Please Resources

Everything you need to review code, clear tickets, track your moral ledger, and uncover every ending in Agents Please.

Latest Updates

Discover the newest guides, tips, and content

Agents Please how to play: Step-by-Step Setup Guide

Learn Agents Please how to play with a clear first-match setup guide covering objectives, turns, agents, resources, and beginner strategy.

Sep 11, 2026guide
Read more →
Agents Please day 1 walkthrough: Step-by-Step Guide

Follow this practical Agents Please day 1 walkthrough to learn the opening routine, prioritize objectives, avoid early mistakes, and build a reliable first-day plan.

Sep 11, 2026walkthrough
Read more →
Agents Please system requirements: PC Readiness Guide

Check the verified status of Agents Please system requirements, compare hardware tiers, and prepare your PC before installation.

Sep 11, 2026steam
Read more →
Agents Please full walkthrough: Step-by-Step Route Guide

Use this Agents Please full walkthrough to organize objectives, track progress, test routes, and avoid costly mistakes during a first clear.

Sep 11, 2026walkthrough
Read more →
Agents Please choices: Step-by-Step Route Guide

Use this Agents Please choices guide to plan decisions, track flags, manage resources, and avoid unwanted route outcomes.

Sep 11, 2026choices
Read more →
Agents Please best choices: Tier List & Team Setup

Find the best Agents Please choices with a practical tier framework, team roles, upgrade priorities, and flexible setup tips.

Sep 11, 2026choices
Read more →
Agents Please contract objectives: Step-by-Step Guide

Learn how to evaluate, prioritize, and complete Agents Please contract objectives with a practical planning and troubleshooting workflow.

Sep 11, 2026gigs
Read more →
Agents Please ending requirements: Verification Guide

A practical guide to checking Agents Please ending requirements, identifying reliable conditions, and avoiding unverified ending claims.

Sep 11, 2026endings
Read more →
Agents Please endings: Route Planning & Choice Guide

Plan your Agents Please endings with a spoiler-aware route guide covering choices, checkpoints, save management, and ending verification.

Sep 11, 2026endings
Read more →
Agents Please decision guide: Choose an AI Agent

Use this Agents Please decision guide to compare autonomy, data access, governance, deployment risk, and business fit before selecting an AI decisioning agent.

Sep 11, 2026choices
Read more →
Agents Please contracts guide: Terms, Exit & Rights

Learn how to compare Agents Please contracts, evaluate terms, protect your options, and choose agreements that support long-term progress.

Sep 11, 2026gigs
Read more →
Agents Please release date: 2026 Status & Update Guide

Track the Agents Please release date with a clear 2026 status guide, confirmation checklist, announcement signals, and safe update tips.

Sep 11, 2026steam
Read more →
Getting Started

Agents Please Beginner Guide

Agents Please puts you in charge of reviewing code produced by AI agents rather than writing every solution yourself. Each work cycle revolves around selecting a contract, understanding what the requested change should do, inspecting the generated diff, testing suspicious behavior, and deciding whether the result is safe to ship or needs to be fixed.

1

Check the Daily Gig Board

Start by reviewing the available contracts on the Gig Board. Read the requested behavior carefully before opening the generated solution so you know what the code is actually supposed to accomplish.

2

Understand the Contract

Identify the expected inputs, outputs, restrictions, and edge cases described by the task. Keep the original request in mind because an AI agent can produce code that looks convincing while failing the actual requirement.

3

Review the AI-Generated Diff

Inspect what the agent changed instead of judging the result from its explanation alone. Pay attention to altered conditions, return values, validation logic, loops, and any code that changes behavior outside the requested task.

4

Question the Agent's Claims

Treat the agent's summary as supporting information, not proof that the implementation works. Compare its claims directly with the code and the contract requirements.

5

Run Test Inputs

Use test inputs to check normal cases and edge cases before approving a solution. A useful test deliberately targets assumptions in the generated code instead of only checking the easiest successful example.

6

Look for Hidden Failures

Check whether the solution breaks with unusual values, incorrect assumptions, boundary conditions, or behavior the agent did not mention. Small-looking mistakes can turn an otherwise convincing patch into a bad approval.

7

Choose Fix or Ship

Once you understand the implementation and test results, decide whether the code should be fixed or shipped. Base the decision on the actual behavior of the code rather than the confidence of the AI-generated explanation.

8

Build Consistent Review Habits

Repeat the same review order on later contracts: requirement first, code second, tests third, decision last. Consistent reviews make it easier to handle more complicated tasks as progression introduces additional decisions and consequences.

Quick Tips

  • Requirement first, code second, tests third, decision last.
  • A convincing explanation is not evidence - the diff is.
  • Boundary inputs catch what easy tests miss.
  • Small unnoticed edits can turn a clean-looking patch into a bad approval.
Progression

Agents Please Walkthrough

Progress in Agents Please is built around completing contracts and making review decisions across successive workdays. The safest approach is to treat every new assignment as a fresh investigation: understand the request, review what the agent changed, test the implementation, and consider the wider consequences before committing to a decision.

1

Start the Workday

Open the day's available work and review the contracts presented through the Gig Board. Check each task's stated goal before committing to a review.

2

Read the Requested Change

Break the contract into clear requirements before examining the generated code. This gives you a reference point for deciding whether the agent solved the actual problem.

3

Inspect the Proposed Patch

Review the AI-generated diff line by line and identify which parts of the program were changed. Focus especially on logic that controls conditions, validation, outputs, and failure handling.

4

Compare Code and Explanation

Read what the agent says the patch does, then confirm those claims in the implementation. Do not approve a change simply because the accompanying explanation sounds complete.

5

Test the Important Cases

Run inputs that cover the expected use case as well as values that could expose faulty assumptions. Testing is the quickest way to separate a plausible-looking solution from one that actually satisfies the contract.

6

Make the Review Decision

Choose the appropriate fix-or-ship outcome after checking both the requirements and observed behavior. These choices form the central progression loop and influence what follows.

7

Advance Through Department Progression

Continue completing work as progression expands the scope and importance of your responsibilities. Later tasks demand more attention to the consequences surrounding apparently simple technical decisions.

8

Track Major Decisions

Pay attention to choices that go beyond whether a single patch technically works. Approval decisions and ethical judgments contribute to the direction of the playthrough and its eventual outcome.

Choices & Outcomes

Agents Please Endings Guide

Agents Please uses the decisions made during code reviews as more than isolated pass-or-fail judgments. Approval choices, questionable requests, and the player's broader ethical direction contribute to later consequences, so an ending-focused run requires consistent decision-making rather than relying on a single final choice.

Steam Achievements

Agents Please Achievements Guide

Agents Please has 24 Steam achievements tied to progression and the decisions made during code-review work. The most efficient completion strategy is to separate achievements earned naturally from those connected to specific choices and endings, then protect important decision points before committing to a route.

Normal Progression

Missable: No

Continue completing contracts and advancing through the game's standard work progression.

Complete each workday normally while learning the review systems before focusing on specialized achievement routes.

Code Review Decisions

Missable: Yes

Reach situations where an achievement depends on how a generated code change is judged.

Inspect the contract, diff, and test results before choosing whether to fix or ship because the required decision can conflict with another route.

Ethical Decisions

Missable: Yes

Make specific choices when the technically available action creates a wider ethical consequence.

Keep your decisions consistent with the route you are pursuing instead of treating every contract as an isolated technical problem.

Ending Achievements

Missable: Yes

Complete a playthrough while following the decision pattern associated with a particular ending.

Plan ending routes around cumulative decisions and combine compatible decision achievements within the same run.

Alternative Choice Achievements

Missable: Yes

Take a different branch from a decision used during another achievement or ending route.

Use another playthrough for mutually conflicting choices rather than disrupting a nearly completed ending route.

Completion Planning

Missable: No

Finish the remaining achievements after completing the main progression and ending-focused objectives.

Review which achievements were skipped because of opposing decisions, then target only those branches during the next run.

Jobs & Contracts

Agents Please Gig Board and Jobs Guide

The Gig Board is the starting point for daily work in Agents Please. Each contract presents a programming task that must be evaluated through the AI agent's proposed code changes, its explanation, and the available test inputs. A reliable approach is to understand the requested behavior first, inspect what the agent actually changed, test important edge cases, and only then decide whether the solution should be fixed or shipped.

Read the Contract Objective

Start with the actual behavior requested by the job instead of relying on the AI agent's summary. Identify what inputs the code receives, what output or behavior is expected, and which requirements must remain unchanged.

Review the Proposed Diff

Inspect every meaningful line added, removed, or changed by the agent. A small-looking edit can alter conditions, calculations, return values, or control flow in ways that do not match the contract.

Check the Agent's Claim

Compare the agent's written explanation with the code itself. Treat the explanation as a claim to verify rather than proof that the implementation is correct.

Run the Provided Tests

Use the contract's test inputs to see how the proposed solution behaves. Passing an obvious test is useful, but it does not guarantee that the code handles every important input correctly.

Test Risky Inputs

Pay special attention to boundary values, alternate branches, repeated operations, and inputs that could expose incorrect conditions or calculations. These checks are especially useful when the agent has changed core logic.

Decide Between Fix and Ship

Request a fix when the implementation does not satisfy the contract or when testing exposes incorrect behavior. Ship only after the code, explanation, and observed test results agree with the job requirements.

Consider Progression Impact

Contracts are part of the game's wider progression rather than isolated puzzles. Consistently careful reviews help avoid bad approvals while your daily work and department progress continue.

Choices & Consequences

Agents Please Moral Ledger and Choices Guide

Agents Please connects technical review decisions with ethical consequences through its Moral Ledger system. The important question is not simply whether code runs, but whether approving, rejecting, or requesting changes is justified by what the implementation actually does. Repeated decisions can matter beyond the current contract, so technical correctness and the consequences of deployment should both be considered.

ChoiceImmediate EffectWhat to CheckLong-Term Role
Approve a Correct SolutionThe reviewed code is accepted for deployment and the current job proceeds.Confirm that the implementation matches the contract, produces the intended results, and does not hide unwanted behavior.Supports a pattern of justified approvals based on verified code rather than agent claims.
Approve Without Proper TestingCode can be shipped before important behaviors have been verified.Run relevant inputs and inspect changed branches before accepting the agent's solution.Careless approvals can contribute to later consequences when the shipped behavior does not match the intended task.
Request a FixThe proposed implementation is not accepted in its current form.Use this when tests, code inspection, or the contract requirements reveal a real problem.Shows a preference for correcting flawed work instead of shipping it simply because an agent claims success.
Reject a Misleading Agent ClaimA mismatch between the AI explanation and the actual code is treated as a review failure.Compare the explanation line by line with the changed logic and observed test output.Helps prevent confident but incorrect AI explanations from driving your decisions.
Judge Code by BehaviorThe decision is based on what the program actually does when reviewed and tested.Focus on conditions, state changes, calculations, returned values, and test results.Keeps moral and technical decisions tied to observable consequences rather than presentation.
Consider Deployment ConsequencesThe review goes beyond syntax and asks whether shipping the implementation is the right outcome.Look for behavior that technically runs but conflicts with the requested goal or creates harmful side effects.Important choices can feed into later events and ending-related outcomes tracked across the game.
Code Review

Agents Please Code Review and Testing Guide

Code review is the central skill in Agents Please. The safest method is to begin with the job requirements, inspect the diff without trusting the agent's explanation, trace the changed logic, and then run inputs designed to exercise both normal and unusual cases. Your final decision should be based on the program's actual behavior.

1

Understand the Requested Behavior

Read the contract first and reduce it to a simple rule: what information goes into the program and what should happen as a result. This gives you a baseline for judging every later change.

2

Read the Diff Before the Explanation

Inspect the changed code directly. Look for altered values, conditions, loops, function behavior, and return paths that could change the program's result.

3

Trace the Changed Logic

Follow the code in execution order using a simple example input. Track variable values and determine which conditions or loops will run before using the built-in tests.

4

Compare the Agent's Explanation

Now compare the AI agent's description with the implementation. If it says one behavior was fixed but the relevant condition, calculation, or branch still behaves differently, treat that mismatch as a warning.

5

Run a Normal Test

Start with an ordinary input that represents the contract's most common case. Confirm that the actual output matches the expected result.

6

Run Boundary and Alternate Tests

Try inputs that reach different branches or sit near important limits. These tests can reveal off-by-one logic, incorrect comparisons, missing cases, or loops that behave correctly only for the easiest input.

7

Check for Unrelated Changes

Make sure the solution does not change behavior outside the requested task. A patch can solve one test while accidentally altering another part of the program.

8

Fix or Ship

Request a fix when the implementation fails the requirements, produces incorrect test results, or contradicts the agent's claims. Approve deployment when the code has been inspected and its behavior matches the contract.

Programming Reference

Agents Please Python-like Language Guide

Agents Please uses a runnable Python-like programming language for its code-review tasks. Players do not need to become professional programmers, but understanding basic control flow makes suspicious changes much easier to spot. Read code from top to bottom, follow variable values, identify which branches execute, and compare the final result with the contract's expected behavior.

Variables

score = 10
bonus = 5
total = score + bonus

Variables store values that later expressions and conditions can use. When reviewing a diff, check whether the agent changed the value being stored or replaced the variable used in a calculation.

Common mistake: Updating the wrong variable or using an old value in the final calculation.

Conditions

if score >= 10:
    result = "pass"
else:
    result = "fail"

Conditions decide which branch of code runs. Small changes to comparison operators can completely change boundary behavior.

Common mistake: Using > instead of >=, reversing a comparison, or placing the correct action in the wrong branch.

Boolean Logic

if has_key and door_open:
    enter = True

Logical operators combine multiple requirements. Review whether all required conditions should be true together or whether either condition is enough.

Common mistake: Replacing an and condition with or and allowing a branch to execute too easily.

Loops

for item in items:
    total = total + item

Loops repeat logic across multiple values. Trace at least two iterations when a changed loop affects totals, counters, or accumulated results.

Common mistake: Resetting an accumulated value inside the loop, skipping an item, or repeating one iteration too many.

Counters

count = 0
for item in items:
    count = count + 1

Counters are commonly used to track how many times something happens. Their initial value and update position both affect the result.

Common mistake: Starting from the wrong number or incrementing only inside one conditional branch.

Functions

def calculate_total(a, b):
    return a + b

Functions package reusable logic and return results to the caller. When a function changes, check both its internal calculation and the value it returns.

Common mistake: Calculating the correct value but returning a different variable or returning before all required logic runs.

Function Inputs

result = calculate_total(4, 6)

Arguments provide values to a function's parameters. Make sure the agent has not changed their order or passed a value that represents the wrong piece of data.

Common mistake: Swapping arguments when their positions have different meanings.

Return Values

if value < 0:
    return 0
return value

A return statement ends the current function and sends a value back. Early returns are important because code below them will not run on that path.

Common mistake: Returning too early and skipping logic required for some inputs.

Test Inputs

input: 10
expected: "pass"

Tests let you compare expected behavior with what the reviewed code actually produces. Use more than one input when different conditions or branches are involved.

Common mistake: Approving code because a single easy test passes while another branch remains incorrect.

Boundary Cases

value = 10
if value >= 10:
    valid = True

Values exactly at a rule's boundary are especially useful for checking comparison logic. Testing just below, exactly at, and just above the boundary can expose subtle mistakes.

Common mistake: Using the wrong comparison operator and failing only when the input equals the threshold.