Self-Improving Agent Networks Without Fine-Tuning: Getting Better at a Task Without Changing a Single Weight

How a Neuro San agent network learned from experience without changing a single model weight, achieving a nearly 40× performance improvement and the #1 AI leaderboard ranking on Skyfall AI’s Mini Amusement Parks (MAPs) benchmark.

Key Takeaways

• We built a learning harness that enables AI agent networks to improve across repeated tasks without fine-tuning or updating model weights.

• Using persistent memory and deterministic evaluation, the system learned from completed episodes by preserving successful strategies and discarding unsuccessful ones.

• Across seven autonomous runs, performance improved nearly 40×, increasing from 12,121 to 483,019 reward without any human intervention between episodes.

• Built entirely in Neuro San, the system reached the #1 position on the Mini Amusement Parks (MAPs) AI leaderboard.

• The results suggest that meaningful learning can emerge from the architecture surrounding language models – not just from training larger models.

Large language models have become remarkably capable at reasoning, planning, and using tools, but they share a fundamental limitation: they do not learn from experience.

Give the same LLM agent the same task one hundred times and, without fine-tuning, the hundredth attempt is fundamentally no smarter than the first. It may perform better because of randomness or worse for the same reason, but it never accumulates knowledge about what actually worked. Every new attempt begins from essentially the same starting point.

That limitation becomes even more important for multi-agent systems. A network of specialized agents can collaborate to solve problems that would be difficult for a single model, but the network itself still inherits the same constraint. Once an episode ends, everything it discovered disappears unless a human manually rewrites prompts or retrains the underlying models.

We wanted to explore a different approach. Instead of teaching the models, could we teach the system around them?

Rather than modifying model weights through fine-tuning or reinforcement learning, could an agent network improve simply by evaluating its own decisions, preserving successful strategies, rejecting failed ones, and carrying those lessons into future episodes?

To answer that question, we built a deterministic learning harness around a Cognizant Neuro® San multi-agent system. The language models themselves never change. Instead, the surrounding infrastructure evaluates completed episodes, rewrites the strategy documents the agents use, and continuously improves the network through structured memory rather than updated weights.

Across seven autonomous episodes, the system improved from 12,121 reward in its first run to 483,019 in its seventh, nearly a 40× improvement, without changing a single model parameter or requiring any human intervention between runs.

Built entirely on Neuro San, the system also reached the #1 position on the Mini Amusement Parks (MAPs) AI leaderboard, outperforming every other published AI system on the benchmark.

A Business Benchmark for Learning

MAPs is only a simulation, but it represents something much larger.

Our long-term vision is to build agentic systems that can generate ideas, test them, operate businesses, reinvest what they earn into new ventures, and continuously improve from their own experience. Before attempting that in the real world, we first needed to answer a much narrower research question in a controlled environment where every decision could be measured objectively.

Mini Amusement Parks (MAPs), introduced by Skyfall AI, provided exactly that environment. In the simulation, an AI agent is responsible for building and operating a virtual amusement park over one hundred simulated days, making business decisions that balance short-term profits with long-term growth. Although the benchmark revolves around managing an amusement park, the underlying challenge is fundamentally about business strategy. It measures how well an agent allocates capital, balances short-term performance against long-term investment, and adapts its strategy over time.

Each episode lasts one hundred simulated days. Every day, the agent is allowed exactly one business decision. It might build a roller coaster, hire another janitor, place a souvenir shop, or invest in research. Once that decision is made, the simulator advances a day. Guests arrive, the park operates, and by closing time the financial outcome of that decision becomes part of the episode's cumulative reward. 

Animation 1: A single day in MAPs. The network commits one decision, the simulator advances one day, and the resulting reward becomes part of the episode.

Additionally, only the cheapest attractions are available at the start of an episode. More profitable rides remain locked behind increasingly expensive research. Investing in research hurts early profitability because it consumes valuable capital, but delaying that investment limits how much revenue the park can generate later. Every dollar earned must therefore be reinvested carefully, whether into new attractions, additional staffing, expanded infrastructure, or unlocking more advanced technologies.

That tension mirrors the broader problem we ultimately care about. Successful businesses constantly balance today's profits against tomorrow's growth. MAPs compresses that challenge into a repeatable simulation where every decision is measurable, every episode can be replayed, and every strategy can be evaluated objectively. 

It also happens to be an exceptionally difficult benchmark. On the medium difficulty setting used in this work, human players still outperform today's strongest published LLM agents by roughly 10×. The challenge is not to make one good decision but to make one hundred interconnected decisions that compound over time.

Learning Across Episodes

MAPs also exposes a fundamental limitation of today's agent systems.

Point an LLM, or even a network of LLMs, at MAPs and run it through one hundred episodes using the same prompts and the same models. The hundredth episode is no better than the first, and sometimes it is worse.

That is not because the models stop working. It is because they never actually learn. Every episode consists of one hundred separate business decisions. Language models are inherently non-deterministic, so some episodes will naturally outperform others. A particularly strong run may simply reflect the model's existing knowledge or a fortunate sequence of decisions rather than a strategy it deliberately discovered. Just as importantly, there is no guarantee those profits can ever be reproduced.

Nothing accumulates across episodes. The system cannot determine which decisions led to success, distinguish genuine strategies from lucky outcomes, or carry proven ideas into the next run. Every episode effectively starts from scratch.

This is a fundamental property of today's LLMs. They are frozen at training time, and any agent network built on top of them inherits that same limitation. Larger models may raise the starting point of every episode, but they do not allow the system itself to become better through experience. Fine-tuning could address that problem, but retraining models after every completed episode quickly becomes expensive, operationally complex, and impractical.

So instead of changing the models, we built a learning harness around them.

The harness is deterministic infrastructure that turns a fixed network of agents into a system capable of learning across episodes. Rather than updating model weights, it records successful strategies, discards unsuccessful ones, rewrites the strategy books used by the agents, and carries those lessons into future episodes. The language models never change. There is no human in the loop. Every improvement comes from the memory the system builds for itself.

Built entirely on Neuro San, that learning harness ultimately climbed to the #1 position on the MAPs AI leaderboard.

Figure 1. Mini Amusement Parks leaderboard. The leaderboard highlights the network built with Neuro San won the #1 spot at the top of the board with the highest score. 

Here is how that system works.

Implementing the Learning Harness

The learning harness consists of two complementary pieces. The first is a multi-agent network responsible for running the amusement park one simulated day at a time. The second is the deterministic infrastructure surrounding that network, responsible for evaluating completed episodes, preserving successful strategies, and improving future ones.

The language models themselves never change. Every improvement comes from the system built around them.

Running the Park: The Player Network

Rather than asking a single language model to operate the park, we use a specialized multi-agent network called Player, built in Neuro San using the Adaptive Agent-Oriented Software Architecture (AAOSA) design pattern. The network loops once for every simulated day, making exactly one business decision before the simulator advances to the next turn. The diagram belows shows the network as a graph: the coordinator at the hub, the six specialists around it, and the coded tools they share.

Figure 2. The Player network. A coordinator distributes each turn across domain specialists before deterministic validation tools verify and execute the selected action.

On each turn, a coordinator (the front-man) reads the park's current state and fans a query out, in parallel, to a set of domain specialists, one per vertical: rides, shops, staff, layout, research, and guest-survey analyst. Each specialist can read (but not edit) its own strategy playbook and the slice of park state relevant to its vertical, and from those it hands back two candidate actions for its area. The coordinator reads its own playbook, weighs the candidates against the strategy written there, and picks one action. Before the action gets fired, the LLM hands the decision over to two deterministic gates that check whether the proposal is valid.

The first gate is FinanceGate, a coded tool that does what the LLMs are unreliable at: arithmetic. It calculates the one-time build cost against the cash on hand, the daily operating cost, and whether the investment can still earn itself back in the days that remain, all computed accurately from the game's economics tables. Every action the player proposes is sent to the gate, which returns a flat approve or reject.

The second gate, ProposeAction, checks the approved action against the game's rules and action syntax before the simulator advances at all and writes the validated proposal to disk. If it's malformed or against policy, the environment is left untouched and the player is re-prompted with the reason. Only once it is written to the disk does the loop pick up that proposal and fire the step through ActionDispatcher coded tool. Keeping the gates and the dispatch in code, not the agent network, guarantees exactly one clean step per turn and spends no tokens on the mechanical work. The LLM is called only for decision making.

A loop this long also gets expensive fast, seven agents a turn, a hundred turns and each agent dragging its whole history along. So we wrap each agent in middleware that trims the chat back to just the new message each turn and caches the static system prompt so it isn't re-billed on every call. The player ends up stateless, and remembers nothing between turns except what the harness has written to disk. That keeps an episode cheap, and it forces a discipline the whole design leans on: the acting network has no private memory to hoard, so anything worth keeping has to be written down to disk where the rest of the system can read it, because the player isn't the only network at work.

All of that is enough to play MAPs. None of it makes the next episode any better than the last.

Three Networks, Three Timescales

To improve across episodes, the agent network has to reflect: record what worked, discard what didn't, and carry the rest into the next episode. We tried a few arrangements before settling on the current one. Our first version folded the reviewer into the same network as the player, and it bled tokens: the two halves talked past each other, turn after turn. Splitting them made each sharper about its own job, far cheaper to run, and let us control in code exactly when the reviewer runs. A second lesson followed: a single reviewer checking in every ten days kept patching symptoms with no sense of where the whole episode was headed, and it churned through too many strategies at once, swapping them out before any had the time it needed to prove out. 

So we split reviewing in two: a between-episodes planner that sets the direction, and a mid-episode watcher that course-corrects against it. None of these networks ever share a conversation, instead they coordinate only through plain-text files on disk. We also limit the number of strategies tried at 3 in one episode.

The result is three separate agent networks, each a mind with its own goal and its own timescale:

• The player network: The network described above - it plays one action a day from the context it's given, and never looks back.

• The planner network: Runs before and after each episode. At episode start, it compares the best episode ever recorded against the most recent one, works out which strategies worked, which didn't, and what to carry forward, then writes the plan the next episode will follow: a day-phased checklist plus a short strategy brief for the coordinator and each domain specialist, along with up to three fresh strategies to trial. The player re-reads that plan every turn. At episode end, it does a thin close-out: promoting the trials that proved out and retiring the ideas that stopped paying off. The diagram below shows this split as episode_start and episode_end agent connected to all its tools.

Figure 3. The Planner network. The Planner network operates between episodes, analyzing completed runs, updating strategy playbooks, and generating the plan for the next episode.

• The watcher network: Runs every ten days, at days 10, 20, … 90 of the episode. It reads the episode's telemetry so far, diagnoses the reward trajectory, and logs small course-corrections (micro-trials) the specialists act on next turn, checking that the planner's strategies are actually landing without duplicating them. It also judges one thing: is this episode still worth finishing? If there's no plausible path to the target by day 100, it calls the episode doomed and the loop aborts it early instead of wasting days. The diagram below shows it as a single analyst agent wired to its tools.

Figure 4. The Watcher network. The Watcher network monitors progress during an episode, evaluates reward trajectories, proposes course corrections, and terminates episodes that are unlikely to surpass the current champion.

Separating these responsibilities prevents any single network from becoming both decision maker and evaluator. Instead, strategy formation becomes an iterative process of proposal, critique, and refinement.

The three networks communicate exclusively through deterministic files rather than conversation history, making every learning decision reproducible and fully inspectable.

The Strategy Playbook: Persistent Memory

Proposing plausible ideas is the easy part; the real work is making sure a good episode's gains survive a bad one. Everything so far happens within an episode. What happens between episodes is what actually compounds, and it comes down to three moves: keep what's proven, cut what's hopeless before it costs much, and always start the next episode from the best the system has ever managed.

Everything an agent knows for its own slice of the game lives in its strategy playbook: a plain-text file it reads at the top of every turn, one for each specialist and one for the coordinator. Each playbook has three parts.

1. The fixed reference

The first part is the game's documentation and economics tables for that vertical: the cost, benefits, and rules of every action the agent can take. The rides table, for example, lists each ride and tier with its build cost, capacity, ticket cap, guest happiness and how long it takes to pay for itself. It comes straight from the MAPs documentation and never changes from episode to episode. The agents read it each day so they never have to guess or estimate the figures a decision depends on, and it is the same reference FinanceGate computes against, so the model's judgment and the code's arithmetic work from one source of truth.

2. The learned strategy

The second part is the strategy the system has worked out for that vertical, both what it has already proven and what it is currently testing. Proven rules are the ones confirmed in earlier episodes, like when a ride is worth upgrading a tier, or which shop to place first. They begin from a hand-written baseline, a read-only seed, and grow only as new rules are confirmed, each tagged with the episode it came from. They are read every turn and take priority over hunches.

Proposed strategies enter as a trial. The planner proposes up to three candidate strategies per episode, and because a profitable episode never tells you which of them earned the money (and a single good result might just be luck), each is written as a falsifiable hypothesis in three parts:

1. A rule: a general instruction the agents follow, not a one-off observation.

2. A success condition: a specific metric, a direction, and a window of days to check it over, long enough that one lucky or unlucky day can't fake the result.

3. A failure condition: the exact result that would prove the rule wrong.

A trial steers real decisions for the full 100-day episode, then at close-out it is judged against the deterministic log, never the model's own account, and by a different network than the one that made the calls: the planner network grades, not the player network. The verdict is one of three:

• Confirmed → written into the proven rules above.

• Falsified → dropped, and logged so it is never proposed again.

• Inconclusive → carried forward untouched, for another trial.

Every rule tried and every verdict is kept in an append-only trial ledger that is never wiped between episodes, so a falsified idea stays dead instead of coming back as a "new" proposal three episodes later.

3. The episode's plan

The third part is the episode's marching orders, written fresh by the planner at the start of each 100-day episode and pinned at the top of every playbook: a short strategy summary (the direction for this episode, what the coordinator and each specialist should prioritize and what to avoid) and a day-phased checklist of roughly what the park should look like by day 10, 30, 60, and on. The player re-reads it every turn so it never loses the thread. It runs strictly forward: the plan is set at the start and does not change mid-episode.

Across episodes, though, the best plan is never thrown away. Every episode's plan is snapshotted to disk, and an episode that finishes clean and beats the best reward on record becomes the champion: the single best plan the system has produced. That champion is where every later episode starts, and it holds until a better episode beats it, so the progress a good episode makes is never lost.

The watcher guards the other direction. Alongside the micro-trials it logs mid-episode, it keeps judging how well an episode is going. A hopeless one just burns tokens and time on something that cannot reach the reward we want. And letting it run to the end can drag down the episodes that follow, throwing away hard-won progress over one or two bad strategies. So it grades the episode every ten days as on-track, underperforming, or doomed: in the first 50 days a doomed verdict takes two strikes before we pull the plug; later, one doomed verdict ends the episode at once. Once an episode is confirmed doomed, the runner stops spending tokens on it and fast-forwards to the end of the 100-day episode with empty wait() moves to book the loss cheaply. It marks all of that episode's trials failed and rolls back to the previous champion. The next episode then builds forward from that champion rather than from the wreckage, all as a plain file copy, with no model in the loop.

So the learned strategy and the episode's plan hold two different kinds of memory. The learned rules are durable, hard-won facts about what works, kept across every episode. The plan is one episode's coherent, step-by-step strategy, rewritten each time. Because they are separate, a doomed episode's plan can be thrown out and rolled back to the champion without a single hard-won rule going with it.

Results: From Experience to Performance

The learning harness was designed to answer a simple question: can a fixed network of language models become better through experience without changing a single model weight?

To find out, we ran the system through seven complete MAPs episodes. Once the first episode began, everything that followed happened autonomously. The same language models, prompts, and code were used throughout every run. No prompts were rewritten, no weights were updated, and no human intervened between episodes. The only thing that changed was the knowledge the harness wrote for itself.

The result was a nearly 40× improvement, increasing from 12,121 reward in the first episode to 483,019 in the seventh. Built entirely on Neuro San, the learning harness also reached the #1 position on the MAPs AI leaderboard, outperforming every other published AI system on the benchmark. More importantly, it demonstrated that meaningful improvement could emerge without changing the underlying language models at all.

Figure 5. Performance across seven autonomous episodes. Without changing model weights or prompts, the learning harness improved from 12,121 to 483,019 reward through accumulated experience alone.

The improvement was not the result of a single breakthrough. It emerged gradually as the system accumulated experience. Early episodes relied on conservative strategies that generated steady income but limited long-term growth. As successful patterns were identified and written into persistent memory, later episodes became increasingly willing to invest in research, unlock higher-value attractions, and sacrifice short-term profit in pursuit of substantially larger returns over the course of the simulation.

Perhaps more importantly, progress was not perfectly linear.

Episode 5 established what was then the highest score, reaching 331,642 reward. Episode 6 regressed to 195,812 while exploring new strategic ideas. Instead of allowing that regression to become the new baseline, the learning harness preserved the Champion strategy from Episode 5 while selectively incorporating only the strategies that had been independently validated. Episode 7 then began from that stronger foundation and achieved a new record of 483,019 reward.

Figure 6. Learning across episodes. After a performance regression in Episode 6, the harness preserved the previous champion, retained only validated strategies, and reached a new best score in Episode 7.

This behavior illustrates one of the key advantages of the architecture. Traditional agent systems have no mechanism for distinguishing genuine improvements from lucky outcomes. Every new run begins with the same capabilities, regardless of what happened previously. In contrast, the learning harness continuously evaluates its own decisions, preserves strategies that consistently contribute to success, rejects those that do not, and protects the best-performing overall plan from being overwritten by unsuccessful experimentation.

The result is a system that can continue exploring new strategies without forgetting what it has already learned.

The leaderboard ranking is an important validation of that approach, but it is not the primary contribution. More significant is what the ranking represents: the system did not simply improve relative to its own starting point. It improved enough to outperform every other published AI system on the benchmark while leaving the underlying language models completely unchanged.

Why It Matters

This project began with a simple question: can an agent network improve from experience without modifying a single model weight?

On the MAPs benchmark, the answer appears to be yes.

By surrounding fixed language models with a deterministic learning harness, the system became nearly forty times more effective across seven autonomous episodes while using exactly the same underlying models throughout. Rather than learning through gradient updates, it learned by evaluating completed episodes, preserving successful strategies, rejecting unsuccessful ones, and carrying those lessons into future runs. Built entirely on Neuro San, the resulting system also reached the #1 position on the MAPs AI leaderboard, demonstrating that meaningful improvement can emerge from the architecture surrounding language models rather than from the models themselves.

The significance of this work is not that an AI learned to run an amusement park. MAPs is simply the proving ground. What matters is the underlying principle: a fixed network of language models can become progressively more capable through structured experience, deterministic memory, and objective evaluation without requiring fine-tuning or human intervention between episodes.

That idea extends well beyond this benchmark. Any environment with measurable outcomes, repeatable evaluation, and clear feedback loops has the potential to benefit from the same approach. Instead of treating every agent run as an isolated interaction, we can begin building systems that accumulate experience over time, refine their own strategies, and continuously improve while remaining fully inspectable and reproducible.

For us, the learning harness is not simply a solution for MAPs. It is a step toward a broader class of AI systems that improve through experience rather than retraining.

Future scope

The next challenge is not simply achieving a higher score on MAPs. It is expanding the same learning principles to increasingly complex agent systems.

Today, the harness refines strategies for operating a simulated business. In the future, we envision applying the same architecture to the process of building the agents themselves. Rather than relying on human engineers to rewrite prompts, adjust workflows, or refine collaboration patterns, the learning harness could evaluate its own agent networks, identify better organizational structures, and iteratively improve how those systems are designed.

Our longer-term vision extends beyond simulations entirely. We ultimately want to build autonomous agent systems capable of identifying business opportunities, testing ideas in controlled environments, launching real products and services, measuring outcomes, and reinvesting what they learn into future ventures. In that world, learning would no longer stop when a model finishes training. It would become a continuous process driven by real-world experience.

MAPs represent the first step toward that vision. Its value is not the amusement park itself, but the controlled environment it provides for studying how agent networks can accumulate knowledge across repeated experience. The same principles demonstrated here can ultimately support increasingly capable systems operating in domains far beyond a simulated park.

This work demonstrates that meaningful improvement does not necessarily require changing a model's weights. A fixed network of language models can become progressively more capable by surrounding it with deterministic infrastructure that remembers what worked, evaluates what did not, and continuously refines its own strategies over time.

We set out to answer whether an agent network could improve without changing a single model weight. On MAPs, it did. More broadly, we believe the next generation of AI systems will not be defined solely by larger models, but by the learning systems we build around them.