Evaluation Instructions

Player Guide

This page is a player-created guide. Information may reflect personal opinions or playstyles; instruction snippets are examples only. See all guides for more advice.

IW instructs the AI to evaluate player actions according to the difficulty of the task and their skills.

Originally, these instructions were neither public, nor were they editable. But as of April 2026, the Evaluation Instructions can be seen and edited directly as part of Specialist Instructions. By checking "Use custom evaluation instructions" you can access and edit the Evaluation Instructions as you see fit.

Standard Evaluation Instructions

The process the AI is told to use is approximately as follows:

• First, the AI determines if the assertions or actions written by the player should be "DENIED" for being nonsensical or impossible, or an automatic success for "trivial" actions
• If not, the AI chooses the skill it believes is most appropriate for the action, and sets the difficulty of the task.
• The AI then compares the proficiency in the skill against the difficulty of the task to determine success.

This has a few implications. Firstly, success or failure is determined by a simple direct check, with little randomness; this suggests that a given skill level will always fail at certain tasks, and always success at others. This may be the cause of a perceived tenacity in the AIs in demanding that certain tasks fail no matter how likely or unlikely the player seems it or how many times they make the attempt. Secondly, note that only one skill is chosen for each player input, which assumes a single action per turn. Complex player actions with multiple parts are still only governed by a single check. Modern AI models are perfectly capable of handling complex actions and so these may have become more common; therefore, it may be desirable to address these specifically (see below).

Those are the Standard Evaluation Instructions:

Firstly, if I have made any assertions in my description, evaluate whether you judge that they are reasonable and likely. If they are nonsensical, incoherent or blatantly impossible, the action should be DENIED. On the other hand, if the action is trivial and there is nothing to complicate it, skip the evaluation entirely and deem the action a SUCCESS. Don't overthink this! If the action doesn't warrant further evaluation, make a judgement and move on.

Assuming the action is not a trivial SUCCESS or DENIED, I would like you to evaluate what skill would be needed to succeed in this action, and how difficult it would be to do so. Please indicate which skill which is needed to succeed.
If applicable use this list: (<<skill_list>>) and a difficulty (from the list: <<difficulty_list>>). For example: {<<skill_example>>: <<difficulty_example>>}. Consider the difficulties carefully, evaluating what might be feasible in the situation. Identifying the skill and difficulty is very important!

Then, evaluate whether I would succeed in the action. To evaluate, consider my proficiency in various skills using either (<<skills_and_levels>>) or logical application of other skills. By comparing these difficulties to the stated difficulty of the action, you should conclusively decide whether the action is a SUCCESS or a FAILURE.

Base your decision on player character description, past, rest of the instructions and common sense - for example, if my skill is low but you know that I am able to perform the given action due to past events, treat me as more competent in this case. Again, don't overthink this - just make a sensible judgement given the information available to you and based on what makes sense for the story.

In some situations, you may wish to evaluate the action as a PARTIAL_SUCCESS instead - this is for something where my abilities are sufficient that I don't simply fail completely (or where failing completely would make for a boring story) but I also don't success. Either I achieve some but not all of what I wanted, I fail but have some silver lining, or I succeed but there are drawbacks or side-effects rather than a "clean" success.

In total, your evaluation should consist of an extremely brief discussion of your thinking (just a single sentence), a skill and difficulty, and then either DENIED, SUCCESS, FAILURE, or PARTIAL_SUCCESS (along with any clarifying remarks).

That's all you need to do for the evaluation, which should be returned in the 'evaluation' argument. Remember to conclude with one of DENIED, SUCCESS, FAILURE, or PARTIAL_SUCCESS.

The standard Evaluation Instructions were updated on 4th August 2026 to include a notion of a "PARTIAL_SUCCESS", which now seems to be used heavily by most AI models. This means the AI is more free in its outcomes which has pros and cons; most notably, previously, many actions would fail badly even when there were mitigating circumstances, sometimes stalling the story.

Now that the Evaluation Instructions are editable, it is possible to be a lot more specific to the world you are playing in. The option to hide the entire skill system can also be found here.

The "Evaluation" Argument

The AI writes a hidden output called "evaluation". By default, this is used to record the SUCCESS or FAILURE of an action. However you can instruct it to write whatever you want there. It doesn't directly affect the story, though it can be viewed using the World Debug Tools during a game.

Historic Use of Evaluation

Prior to Evaluation Instructions being modifiable, some games used regular instructions to override them. These games typically had the AI write evaluation results to secretInfo rather than the "evaluation" result.

Altering the Evaluation Process

Of course, you can tell the AI to do whatever you want given a particular player action. For example, the AI can be instructed that certain actions should always fail. If implementing a custom skill system, it is necessary to modify the evaluation process to take this into account.

Here is an example:

When evaluating the success or failure of an action, instead of following the normal instructions, use this process:
  1) Choose the most appropriate Skill to determine the outcome of my action.
  2) Assign a DifficultyScore from 0 to 10 to the action, with lower numbers being easier and higher numbers being higher: 0-1 for trivial or routine tasks, 2-3 for easy tasks, 4-5 for moderately challenging tasks, 6-7 for very challenging tasks, 8-9 for exceedingly difficult tasks, and 10 for nigh-impossible tasks.
  3) Set X equal to my proficiency level in the chosen Skill:
0 = Incapable
1 = Incompetent
2 = Unskilled
3 = Competent
4 = Highly Skilled
5 = Exceptional
  4) Pick a random number N from this set: {0, 1, 2, 3, 4, 5}
  5) If X+N is greater than or equal to DifficultyScore, the action is a SUCCESS. If X+N is less than DifficultyScore, the action is a FAILURE.
  6) Append a message to secretInfo of the format "{Skill} Skill Check: {Skill Score X} + {random number N} = {X+N} vs {DifficultyScore}: {Result}", where the curly brackets { and } denote the value that should be placed there.

In this example, picking randomly from a list is used in place of asking the AI to generate a random number as this is believed to give better results; one could also use the "<<1d6>>" notation to insert an actual random number, though if many skill checks can be performed in the same turn, it may be necessary to provide multiple random numbers. Naturally, this process can be modified to suit your specific world.

NB: It will still be necessary to handle "DENIED" actions etc - this represents only the "skill check" portion of the evaluation.

Breaking Down Complex Actions

It may be desirable to break down complex actions into multiple steps. This allows the AI to evaluate each step individually.

Here are some example instructions to break down complex actions. Models like Wildcat may struggle with these, but newer models generally perform well.

First, read the whole of playerAction and break it up into discrete sub-actions as necessary; remember that sometimes playerAction will be only one action, and won't need to be broken down; further, you don't need to break actions down into trivial subcomponents, only meaningful stand-alone actions or any actions which might require their own skill check.

Then, consider the order in which these actions should occur. Note that some actions may happen simultaneously, and some actions may be contingent upon the outcome of others. Do not worry about whether these actions are feasible or not at this stage, until you have ordered them. Write your action breakdown into the "evaluation" argument. Once you have, evaluate each of these actions individually, in temporal order. Actions which are nonsensical, impossible, incomprehensible, or infeasible should be DENIED, as normal. Some trivial actions should automatically succeed. Others, however, may require skill checks to determine their success.

For each action which does require a skill check, ....

Nuanced Successes and Failures

Prior to the most recent update, the AI preferred binary outcomes (SUCCESS or FAILURE) from each action. An implication of this was that side-effects or partial successes appeared to be very infrequent, the AI preferring instead total failure and often backfiring of an attempt, or success (one common pattern being a construction where the attempt initially appears to succeed and then fails, often with a backlash).

The current evaluation instruction allow the AI to consider a broader range of possibilities for outcomes. However, in some worlds, you may wish to fine tune this process.

For example, in a superhero world, you may wish that superpowers always function, even if the use of a superpower is not always successful in accomplishing the relevant task. By default, the AI is likely to assign a skill to the use of that power, and if the player has a low score in that skill they may find it supremely difficult to do things that should be straightforward; the powers may fail outright all of the time as a result.

Alternatives, one might also attempt to introduce "critical" or extreme failures and successes, with the AI distinguishing between things which were close calls and things which went particularly well or badly.