How Do You Turn a Non-AI Race Agent Into Gameplay?

In my previous post, I explored whether AI could make decisions during races in EvoWild Run. I ended up somewhere unexpected.

The race doesn't actually need AI running inside it.

The name Race Agent remained, but the system itself became a set of tactical rules that select commands based on predefined conditions.

Players who don't use AI can configure these rules through the normal game UI. Players who want to use AI can ask an external model to create an Agent File.

Previous post: I Tried to Put AI Into the Race. Then I Realized It Didn't Need AI.

That left me with another question.

How do I turn an ordinary command system into something interesting to play with?

An Agent's command shouldn't automatically become the result

Suppose a Race Agent issues an ATTACK command.

If the Creature always accelerates at maximum power, its individual abilities and current condition don't matter very much.

A heavily fatigued Creature might struggle to accelerate.

Similarly, when an Agent issues MOVE OUTSIDE, the Creature might be unable to move because another competitor is blocking the path, or because its Agility is too low.

So I decided to separate the Agent's command from the Creature's actual action.

Agent evaluates the situation
↓
Agent issues a command
↓
Creature attempts to execute it
↓
Race Engine evaluates abilities,
fatigue, surroundings, Course conditions, etc.
↓
Actual action outcome

The Agent doesn't directly control the Creature. It only issues commands.

The result depends on factors such as Speed, Acceleration, Stamina, Agility, Temperament, current fatigue, surface conditions, weather, and congestion.

I'm also considering several possible outcome grades:

• Excellent
• Success
• Partial
• Failed
• Backfire

The exact evaluation rules haven't been defined yet.

But one relationship is important:

Even when an Agent makes a good decision, the Creature may not be able to execute it as intended.

The same Agent shouldn't work equally well with every Creature

This led to another idea: compatibility between Creatures and Agents.

Imagine an Agent that repeatedly issues aggressive ATTACK commands.

A cautious, slow-reacting Creature and an aggressive, quick-reacting Creature shouldn't necessarily produce the same result with that strategy.

That gives players something to investigate.

Was the Creature not capable enough?

Was the Agent's strategy wrong?

Or was the combination unsuitable?

This also connects the Agent system to breeding.

If a Creature repeatedly fails to change position, the player might examine its Agility. If it struggles during late ATTACK commands, they might compare its Stamina, Acceleration, Temperament, and Agent strategy.

Then comes another decision:

Should I change the Agent, or change my breeding direction?

The original loop was:

Breeding → Race → Next breeding decision

Now it could expand to include:

Agent configuration → State analysis → Strategy or breeding improvement

Of course, whether this compatibility system actually makes the game more interesting still needs to be tested.

But will spectators understand what's happening?

This brought me back to the original problem.

In EvoWild Run, players don't directly control their Creatures after the race starts.

The Agent makes decisions, the Creature attempts to execute them, and the Race Engine determines the outcome.

But if none of that is visible, players may simply see Creatures running around on their own.

So I started thinking about making the Race Agent visible during races.

I don't want a humanoid jockey. That would require additional models, riding animations, and adjustments for different Creature body shapes.

Besides, the Creature should remain the main character.

Instead, my current idea is a small floating orb following above and behind each Creature.

It would usually remain subtle, but react when issuing commands through colour changes, glow, pulses, rings, or icons.

ATTACK could trigger a stronger glow, while CONSERVE could use a calmer visual state.

A glowing orb isn't enough to explain a decision

An Agent changing colour doesn't necessarily tell spectators what it decided.

So I also want important commands to appear as short pop-ups.

For example:

AGENT
ATTACK
Final-phase spurt

↓

PARTIAL
Acceleration reduced by fatigue

Or:

AGENT
MOVE OUTSIDE
Congestion detected ahead

↓

FAILED
No outside path available

That would let spectators follow:

Decision → Command → Execution → Result

To understand why commands succeed or fail, they also need information about the Creature's current state.

Fatigue is particularly important.

For example:

EV-027
4th

FATIGUE 74%

AGENT: CONSERVE

I'm also considering temporary states such as Focused, Excited, Nervous, Boxed In, and Unbalanced.

Displaying everything constantly would make the screen cluttered, so the idea is to show important information only when needed.

What I want is not just a race where players watch positions change.

I want a race where players can understand why the results happened.

A visual concept for the Race Agent

To explore the idea, I also created an image showing a Creature alongside a Race Agent.

This is concept art, not an implemented game screen. The Creature in the image is not the actual S-type model currently under development. The image is only intended to explore how the floating orb and command display might look.

What if Agents could accumulate their own history?

Up to this point, the Race Agent was still an ordinary tactical system.

Create an Agent File, assign it to a Creature, use it in races, and adjust it based on the results.

But then I considered another possibility.

What if players kept using and improving the same Agent over time?

Agent v1
↓
20 races
↓
Analyse weaknesses
↓
Agent v2
↓
Further testing
↓
Agent v3

Instead of creating an unrelated file every time, players could gradually improve one Agent.

That Agent could start accumulating its own history.

Could an Agent become an independent in-game entity?

This part is still under consideration.

What if Race Agents became independent in-game entities, separate from Creatures?

They could have:

• Agent ID and Name
• Creator and Current Owner
• Strategy Definition
• Version History
• Race Results
• Creature Compatibility History
• Ownership History

Creatures would have their bloodlines and race records. Agents could have their own development histories and results.

That also raises the possibility of transferring an Agent to another player.

But there is an obvious problem: Agent Files can be copied.

Because the strategy format is intended to work with external tools and AI, I can't assume the logic itself will be impossible to copy.

So I started separating two things:

The strategy logic

and

the official identity and history of an in-game Agent

Copying a strategy wouldn't automatically give someone the original Agent's creation record, official results, version history, or ownership history.

In other words:

You can imitate a strategy without inheriting the history of the Agent that used it.

How that history would be managed, whether ownership transfers should exist, and whether blockchain should prove important records are all undecided.

A conventional database might be sufficient for some or all of those records.

Agent Builder could become another player role

If creating, analysing, and improving Agents becomes interesting enough, it could support another kind of player activity.

Breeder — develops Creature bloodlines.

Agent Builder — creates and improves racing strategies.

Course Designer — creates Courses.

Tournament Organizer — organizes competitions.

An Agent Builder might specialize in strategies for particular Courses, distances, bloodlines, or temperaments.

That would expand the things players could create:

Creature
Race Agent
Course
Competition / Tournament

I originally started with a game about breeding Creatures and racing them.

Then Courses became something players might create.

Now Race Agents might become another player-created system.

Updating the game structure diagram

I also updated the overall game structure diagram to reflect these ideas.

EvoWild Run — Game Structure v0.2

View the Game Structure v0.2 diagram on Whimsical

This diagram represents the current design direction, not a completed or fully validated implementation.

The previous version showed the basic relationships between Creatures, Courses, racing, and breeding.

Version 0.2 adds Agent Files, commands, Creature State, and race observation and analysis.

Independent Agent identity, history, and transfers are shown separately as ideas still under consideration.

How far should the Race Agent system go?

The current direction is for every racing Creature to have a Race Agent using the same rules.

The Agent issues commands, and the Race Engine determines how the Creature actually responds.

I also want spectators to understand those decisions and their outcomes.

However, independent Agent identities, ownership, transfers, and blockchain integration are still under consideration.

And more importantly, I haven't yet validated whether this system is actually fun to play with.

I originally wanted AI to make decisions during races.

Eventually, I found that the race itself didn't need AI.

But as I continued exploring the Race Agent, several ideas started connecting:

Creature compatibility, breeding feedback, race observation, Agent improvement, and accumulated history.

The next challenge is deciding how much of this belongs in the game, and testing whether I can actually make it work.