Your AI tool isn't broken. It's just full.

Hi, I'm Mike Fox, host of this podcast, "Lone Wolf Unleashed." I help solo founders systemise their businesses so they can switch off sooner and live larger. This week I'm pulling back the curtain on a real data project: 103,000 rows, a client locked into Microsoft Copilot, and a categorisation task that would've taken weeks to do manually.

Here's what I worked through — and what you can take straight into your own business.

The context window is the AI's working memory. Once it runs out, the quality of your outputs tanks — or the conversation just stops. Understanding this constraint is the difference between AI that saves you hours and AI that wastes them.

Working within real-world limitations (not every client is on Claude), I built a strategy to break down a massive data set into token-efficient chunks, set up a structured workflow for Microsoft Copilot to process them in sequence, and then used a manager-agent review layer to QA the outputs before any human had to.

The same principles apply whether you're running Claude, ChatGPT, or whatever tool your organisation has decided is the one. The constraints change. The framework doesn't.

What you'll learn:

• What a context window is and why it limits what your AI can do with large data sets
• How to make your data and your prompts token-efficient before you send them
• A practical chunking strategy for splitting large Excel or CSV files across multiple AI sessions
• How to use a manager-agent role to review and QA your AI outputs
• Which model settings to use for heavy analytical tasks

If you're using AI to make decisions — not just write emails — this episode is for you.

Resources, frameworks, and tools: lonewolfunleashed.com/resources

Mentioned in this episode:

This podcast is part of the Podknows Podcasting ICN Network

You might also like...

Check out the "Websites Made Simple" podcast with Holly Christie at https://websitesmadesimple.co.uk/

G'day. My name is Mike from Lone Wolf Unleashed and today we're

going to talk about how to interact with AI agents and your

AI tools to get the best possible outcome for what you're trying

to do with them. This week I had a data set that

we were looking at. It had 103,000 lines,

which is a lot. It's a lot of data.

And there is a particular problem when you're dealing with data sets

this large and that is it will consume your AI context window.

Now what is that? The context window is basically how much information

the AI can read before it needs to basically compact that and

to reload it, or you need to start a new conversation.

A few months ago, Claude would just run out of context window

and you would need to start a new conversation.

You would basically need to start again.

And remember, wherever you're up to,

it has since got a little bit better than that.

It is now auto-compacting. It's providing a summary of what the conversation

was about so it can continue.

And I haven't had to do that since.

A couple of weeks ago, Anthropic actually increased my context window to

about a million tokens, which was five times the amount that I

was on at the time. It is a game changer because I

haven't seen it compact since.

When we're dealing with data sets this large,

we need to be thinking about how much room the AI has

to work with. This is going to basically be a little bit

of a chat about how we go about planning out how we're

going to use data of this kind with an AI tool and

some strategies that will help us get around some of our constraints.

So the customer that I'm working with for this one is constrained

to — yep, you guessed it —

Microsoft Copilot. It's not my favourite AI tool.

Let's just say that it's probably near the bottom of the list.

But you know what? We have to deal with constraints every day

and this is the one that the customer's dealing with.

The idea here is that we need to be able to feed

Copilot this data set and we need to be able to have

it return a good set of outputs based on the outcome or

the objective that we want.

Basically what we wanted to do was to scan over a bunch

of categories and the descriptions of the cases that were in there

and to return us a new categorisation based on a different parameter,

which is being driven by legislative requirement.

Doing this manually in the past,

you would have to search for trigger words.

It would be a very, very long exercise to go through that

many records. And the idea here is that Copilot will run itself

over those fields and be able to complete that task.

The problem is that it cannot consume that much information at a

time. So number one, let's have a look at our token usage.

We want to be able to make this data set as token-efficient

as possible, and we want to be able to make our prompt

as efficient as possible. I have gone through before about how to

build AI agents, and we want to be able to articulate what

the agent or the AI is supposed to do.

The principles are the same whether you're dealing with an AI agent

or an agent team or whether you're just interacting in a chat.

We want to be able to make all of those things token-efficient.

So the first one is, well,

let's strip out all the IDs that were in there.

They were fairly long. Let's just go one through to 103,000 and

we can match it back to the original data set.

We can create a matching field.

That's number one. Okay, we've saved a few.

What other columns do we not need?

So let's strip out every single piece of information we don't need

in there. And then what we want to be able to do

is we want to be able to articulate the outcome in a

prompt. And we're going to do some testing about how much information

is there. Right. So we tried the first time.

Results were rubbish. It tried to consume too much information and the

results weren't great. So now we're going to chunk our data set

down into manageable data sets.

Let's say we want to do this the long way around just

to make sure that it works.

Okay, let's break this down into 20 data sets.

So we're going to split this out into several different Excel workbooks

and we're going to have a master Excel workbook where it's going

to return some information. So we're going to have 20 workbooks with

just over 5,000 records each. This is much more manageable for the

AI tool because now we're not consuming nearly as many of the

tokens that it has available to use for these activities.

Now, if you're in a Pro version of Microsoft Copilot,

you'll be able to do things like point it towards your documents

for knowledge sources and all those kinds of things.

And in my case, I'm going to assume you're paying for it.

What I would do is I would set up an agent to

take care of this. There is a create agent type option in

there. Create an agent, and in your instructions,

put in what your original prompt was going to be for what

it needs to do.

And then we're going to direct it on how it is supposed

to interact with the files. We have the initial part,

which is easy. It's the —

hey, look at this data, provide me some insights as to these

new categories. That's the easy part.

Now we want to direct it to go,

okay, here is data set one.

We are going to take this,

we're going to put the result in a new workbook so we

can consolidate it all again. And the first thing you're going to

do is name the file that you were in.

Great. It should know that because it has the title of the

thing. And then it's going to return the total number of cases

that are in there. And in the original workbook,

it's going to categorise them all out.

This creates a quick check for us because we can open the

new workbook that has the summaries in it to see that it's

working. We don't have to open up all 20 of these other

ones. We can just have one open that we can see that

it's returning those totals. Once it's done all 20 of those,

we should have our total number of cases that we're looking at

with these new categories.

And we should be able to then combine the other 20 back

into one main big one as a new data set.

Now, this is still a little bit manual.

Yes, I know I could probably run this through Claude in my

current setup in one shot, but again,

if we're dealing with the constraints,

that's what we need to do.

Why are we doing this exercise?

Well, in this case, the client is trying to make a determination

ultimately around the type of resourcing that needs to be held within

teams based on case volume. And there is an understanding at the

moment that there are invisible cases that are not being raised,

just because their operations are fragmented,

or there's not enough governance, or there's not enough ownership.

And the reporting because of that is very limited.

So what we're trying to do here is we're trying to come

from a different perspective, a different angle —

look at the problem from a different angle and go,

okay, well if we've got all these cases and case information,

maybe they've been categorised incorrectly in the past,

or maybe there are other layers to these cases that we haven't

previously understood. Can we figure out what order of magnitude we're looking

at here in terms of any new resource that we would need?

That's the idea. The idea for this particular exercise was not to

go down into very specific case-by-case matters.

It was more to do with how to figure out the bigger

problem. So that's basically in a nutshell how to break down these

big data sets when working with AI tools.

The basic premise when doing exercises like this,

particularly around data analysis, is —

remember we need to check that it's doing it right.

We need to scrutinise its outputs.

We can't just take what it has as gospel.

The other thing too is it's possible to run a multi-stage exercise

here, in that we can feed it the original stuff,

it can return.

We can have now a manager agent run over the top of

it and go — we want to check the work of this

one. Provide us with any of the gaps around the assumptions or

the outputs, and then it can return to you and you can

sort of test and refine from there.

I always highly recommend — and I've mentioned this before —

I always highly recommend running over like a test or a battle

test, a manager review type exercise over the AI outputs.

Remember that the AI is given a role when it is doing

a task for you, and you would go —

well, we were just getting it to check its own homework in

a sense. Yes, you are. But the role that it used to

produce the original content wasn't the role that you've now given it

to go and review. It does break down that time to spot-check

and review as well — for you when you're doing your own

review, which is really super helpful.

Keep those things in mind. The other thing that we need to

think about is the type of model that we're using.

So if you're in a tool like OpenAI's ChatGPT or Anthropic's Claude,

then you'll want to make sure it's in the right mode or

using the right model for these really heavy tasks.

I would be using Opus 4.6,

for example, with extended thinking mode on.

Yes, it does consume more tokens,

but you get a way better outcome and that's what we're looking

for. Better outcomes means less of your time used doing admin work.

What have we covered today? We've covered today that we need to

be thinking about the constraints and we are working with our constraints

of using AI tools within your business.

And maybe it's a decision that you made earlier on about which

tool to use and all that sort of stuff.

I don't recommend really going out to purchase all these different AI

tools. We pick one and we stick with it and we get

really good at using it.

That's the idea. We've covered how to break down these really large

data sets. If you're wanting to get insights on maybe some unstructured

data, or data that we need to have an AI tool run

over — it's not necessarily deterministic —

then we need to break those down into a token-efficient way to

be able to get it to work properly and provide good outcomes.

And then at the end we've covered how to make sure that

it's given the output by running a manager type role over it

and then spot-checking ourselves. That's going to do us today.

Guys, thank you so much for joining me.

I thank you so much. You could be doing so many other

things, but instead you decided to hang out with me and learn

how to break down these data sets to use in AI tools

when you're trying to make big decisions.

This is all about saving time.

You can save more time by heading over to my website,

lonewolfunleashed.com/resources. There's a whole bunch of resources there that you can use.

There's AI stuff, there's process stuff,

there's procedure stuff, there's presentations —

there's heaps of stuff. Go over there,

check that out and I'll see you next week.