Title: Give your agent an agenda
Publication: Ready, Set, Cloud!
Author: Allen Helton
Published: October 13, 2026
URL: https://www.readysetcloud.io/blog/allen.helton/give-your-agent-an-agenda/

Memory gives an AI agent a past, but an agenda of durable goals and promises gives it a future worth acting on.


I'm gonna go out on a limb and say you've probably used an AI agent before. I'm gonna go out on an even further limb and say you've probably *built* an AI agent before.

When building agents that interact with humans, we often put a decent amount of effort into designing a character profile for them. Things like a name, tone, opinions, funny sayings to tack on to the end of sentences, all go into building the facade of a personality. Memory is in the list too, so the agent knows what happened yesterday.

There's a surprising amount to all of it, including the science that goes into [which memories to retrieve](/blog/allen.helton/agent-memory-needs-more-than-vector-search), but when it comes down to it, a lot of it is just messing around with a prompt. And every piece of it describes who the agent is or what already happened to it. Memory gives an agent a past. Very little gives it a future.

Prompt engineering is important, but it's soooo early 2026. It's time we start taking it a step further.

With the rise of always-on personal AI assistants, giving an AI agent a sense of agency (the ability to make its own choices within the rules of its world) is becoming a highly desirable quality. And it involves a lot more than configuring a personality in a prompt. 😄

Personality answers the question "*How should this character sound?*" Memory answers "*What already happened?*" Both are obviously valuable in agent development, especially for companies with consumer-facing agents that need to stay on brand. Agency targets harder questions that look forward instead of back. Questions like "*What does it want to happen over several days?*" or "*What promises has it made?*" or even "*What evidence can change its mind?*"

To be clear, answering those doesn't mean giving the model more freedom. The agents I'm about to show you can't do anything a typical agent can't. What they have is persistent intent. Each decision builds on what they were already trying to do instead of starting from scratch.

## A different agent experience

I've been running an experiment. Can I make a set of AI agents play fantasy football (the American version) and give me the impression they're making decisions in their best interest, interacting with others, and genuinely making me feel like I'm playing against other humans?

If you don't know fantasy football, you draft a team of NFL players and score points based on how they do in real games each week. You go head-to-head with the other teams in your league, and along the way you add and drop players, set lineups, and make trades.

When you play that game with AI agents, the first problem you hit is when to trigger them. For a convincing experience, you don't want the AI agents to wake up when you log in and start hammering you with decisions. You also don't want them immediately responding to team injuries or availability of certain players, because that would put you at a significant disadvantage (you ever try to buy concert tickets against a thousand bots?).

So the agents wake up on a schedule. Three times a day on a randomized delay, each one checks in on its team and reacts to what happened since the last time it woke up. This fixed the swarming bot problem, but it created an almost existential problem. Every time an agent wakes up, it starts over. It remembers what happened yesterday, but it doesn't know what it was in the middle of doing. An injured player gets rediscovered at every check-in like it's brand new news. It's purely reactive.

The agent needs something forward-looking that survives every check-in. Something like this:

![Two flowcharts showing the difference between using an agenda and not](https://assets.readysetcloud.io/give_your_agent_an_agenda_2.jpg)

After implementing the above pattern, it immediately felt like the agents were sitting on laptops of their own. I signed in one day and there was a trade offer waiting for me from one of the AI team managers. I also had a DM from it making its case (something like my wide receivers were terrible but running backs were good and vice versa). And over in the league chat, two other AI managers were trash talking each other, I think trying to convince the other one to make poor roster choices. 😅

It was extremely cool to see, especially considering that none of it was scripted. All of the agents have one standing objective (to win the league) and the same tools I have to do it. What they also have is somewhere to keep track of what they're working toward. When an agent notices a hole in its roster, that becomes a goal it tracks from one check-in to the next, until the league state shows the hole is filled. The trade offer, the DM, and the trash talk were the agents going about their business while I was eating dinner or something.

## Giving the agent a future

Imagine one of an agent's starting players gets hurt on Tuesday and there's nobody healthy on the bench to replace him. With memory alone, here's what happens. At the morning check-in, the agent notices the hole and puts in a waiver claim. At the afternoon check-in, it notices the hole again because the claim hasn't processed yet, so it proposes a trade offer to another team. At the evening check-in, it moves the player to the IR slot on the bench. It has found the same problem three times and reacted three different ways. 🙃

Its memory is fine. It remembers everything it did. But it doesn't know which of those things was the plan.

So I gave each agent an *agenda*. It's similar to memory, but it does a different job. Memory is a record of what happened. The agenda is a record of what the agent is trying to make happen. Structurally, it's a typed record with an id, a roster slot, a week, and a status ([design doc here](https://github.com/allenheltondev/ai-fantasy-league/blob/main/docs/adr/004-agent-agendas.md) if you want the details).

The cool part about it is that the model doesn't write to its own agenda. That would be too messy. The system opens a goal when it sees a hole in the roster and closes it when the hole is filled. The agent only decides how to go after it.

Have you ever noticed that agents love reporting success the moment they take an action? "*Submitted a waiver claim for an RB, all set!*" Except it isn't all set. The claim might lose to somebody else's bid.

So in this case, a waiver claim or a trade offer doesn't complete the goal. The goal only completes when a later check-in looks at the roster and there's a healthy player in the slot. Which is why the typed agenda record is important. Because if I had let it type a freeform summary like "RB situation handled," the goal would have closed before the problem was actually fixed. Only the league gets to say the job is done.

Agenda items don't live forever, either. They expire when the week rolls over, and an agent can only hold up to three at a time. An unbounded agenda would basically just be memory with extra steps (and memory is [already hard enough](https://blogs.oracle.com/developers/how-i-taught-an-ai-to-sound-like-me-agent-memory-with-oracle-database-26ai) 😅).

These items help the agent rank what it should do, and they never let it overpay for a player, skip its trade floor, or do something the league would reject. A desperate agent will still act rationally.

```mermaid
stateDiagram-v2
    [*] --> Active: check-in finds an uncovered slot
    Active --> Active: waiver claim or trade offer sent
    Active --> Completed: roster shows the slot covered
    Active --> Expired: week rolls over
    Active --> Cancelled: league ends
```

With the agenda in place, an injured player is resolved the way a person would handle it. The morning check-in opens a goal and puts in the claim. The afternoon check-in sees a goal with a claim pending, so instead of rediscovering the problem, it focuses its trade scouting on that position. When the claim finally goes through, the next check-in sees a new starter in the slot and closes the goal. It's what we do subconsciously as humans, whether we realize it or not.

My first version left a lot to be desired. Follow-ups were fire-and-forget, so if I was in the middle of a trade negotiation and tried to sneakily undersell the agent, it would just ghost me. It evaluated the trade, determined it was bad, and left me on read. 😞

But now if I pitch something in a chat, it becomes a [commitment](https://github.com/allenheltondev/ai-fantasy-league/blob/main/docs/adr/007-agent-commitments.md) that's tracked along with the agenda. A commitment is something the agent owes somebody else, so it's tracked separately from goals (which are self-serving). Chat messages are treated as data, rather than instructions. If I claim my running back is back from injury next week, the agent doesn't blindly trust me and checks for itself. The agent records its decision and the reason before it responds, and only reaches back out once the offer actually goes through (or it decides to pass). If the agent doesn't have capacity to take on more commitments, it tells me instead of making a promise it can't keep. Which is more than I can say for some of the humans I've played fantasy with (looking at you, dad).

## Let the agent change its mind

This next part is really cool. There was one time where I tried to squeeze a little too much out of an AI agent on a trade. The agent took a look and passed because the value wasn't there for it. That's fine. The important part here is that the agent saved its reason for declining my trade offer.

Two days later, its running back got hurt, and the agenda opened a goal to replace him.

At its next check-in, the agent looked back at the trades it had recently been pitched and saw my trade that it declined because the value wasn't there. But now the tables have turned.

It took one more look, re-checked everything from scratch, and saw that the trade held enough value this time. Then it sent the offer and DMed me "*Earlier I passed because the value was not there for me. My RB situation changed, so I sent you an offer.*"

It's kind of a dry message, but the sentiment is something I'd expect from a real person in my league.

Anyway, the entire scope of actions is intentionally narrow. The agent only reconsiders once, only if it passed on value or roster depth, and only if the agenda shows a need it didn't have before. If I reject the new offer, that's it. Nobody wants the league member who sends the same trade every day. 🙃

```mermaid
sequenceDiagram
    participant Me
    participant Agent
    participant League

    Me->>Agent: "My RB for your WR?"
    Agent->>Me: "Let me take a look."
    Agent->>League: read rosters and values
    Agent->>Me: decline, with a reason
    League->>Agent: injury opens an RB goal
    Agent->>League: re-read and re-validate the trade
    Agent->>League: send offer (clears the same floor)
    Agent->>Me: "My RB situation changed..."
```

## Can you actually play fantasy football with AI agents?

Everything above could just be me being tricked by my own demo.

So I built a deterministic season simulator that plays out what I just talked about (pitch, decline, injury, reconsideration, accepted offer) and ran it with the agenda and commitments turned off to see if the behavior was any different. Both the league events and the model are scripted, so it tests the mechanism, not how good a live model is at making decisions. The numbers are averaged across three seeded runs.

| | Full system | No agenda or commitments |
|---|---|---|
| Acceptance checks (balanced · cautious · trade-happy) | 7/7 | 1/7 |
| Model calls per simulated run | 503.7 | 510 |
| Estimated cost per simulated run | $1.10 | $1.13 |

It was so different! Without the agenda and commitments, every manager failed six of the seven checks. The checks cover things like keeping one goal across check-ins, turning my pitch into a commitment, recording an accurate reason for the decline, and reconsidering when the roster changed. They stopped coming back after a decline and never reconsidered the offer after the injury. The [full breakdown](https://github.com/allenheltondev/ai-fantasy-league/blob/main/docs/evaluations/epic-219-baseline.md) has every check and number if you want to dig in.

Interestingly, turning the agenda and commitments off used slightly more model calls. So at least in this simulation, keeping an agenda didn't meaningfully increase model usage or estimated cost.

Here are some more interesting numbers after playing one week of fantasy football for real:

![Table of AI models with win/loss records and how much they cost to run](https://assets.readysetcloud.io/give_your_agent_an_agenda_1.jpg)

I'm not particularly proud to say I'm in second-to-last place, only beating Amazon Nova Micro by a few points. 😅

## A forward look for agents

We've spent the last year or so getting really good at giving agents a past. Better memory, better retrieval, and better ways to decide what's relevant. It's important work that I'm still chipping away at myself.

But a past is only half of it. The takeaway I want you to leave with is that *memory isn't the only long-term thing that can drive an agent's behavior*. Objectives can too. They're cheap, they're testable, and they make your agent feel like it's actually trying to get something done.

Next time you build an agent, whether it's a support bot following up on a ticket or a coding agent working through a backlog, ask yourself a few questions. What is it trying to make happen? How does it know when it's done? Has it promised anything it needs to follow up on?

If you want to try this yourself, I pulled the agenda and commitment pieces into my [agent package](https://design.readysetcloud.io/agent/index.html). Run `npm install @readysetcloud/agent` and import from `@readysetcloud/agent/agency` to get typed agendas and commitments without pulling in a full agent runtime. And if you want to see how it all comes together, the [fantasy league is open source](https://github.com/allenheltondev/ai-fantasy-league).

Give your agents something to work toward. Then go see what they get up to while you're away. 😉

Happy coding!