skills - method of organizing blocks of agent instructions - automatic pre-load/inclusion

[Oisin Haken (VaclavK)]

hi,

we use skills for two reasons. The first is the normal dynamic skill discovery depending on intent. The second is to essentially provide some order in specialized parts of agents logic so that it is a) reusable across agents ( and not copy paste) and b) easier to modify, view etc instead of having large agent instruction block.

However of course there is the roundtrip penalty.

I was thinking that it could be possible as a feature to configure context provider to "always include" defined skills and then essentially just slap them into instructions?

I don't think this would be unclean etc. and I also believe this seems like a no brainer (but not available atm).

What other strategies do you use to somewhat logically organize your instruction "functions"?

[Wael El Ghazzawi (identity-wael)]

Yes—reusable instruction modules don't have to be dynamically discovered. For the subset you already know every run needs, compose their trusted instruction text into the agent's instructions, or inject it from a context provider before the model call. Keep dynamic discovery for optional skills.

For Python, the current context-provider example shows ContextProvider.before_run(...) and:

context.extend_instructions(self.source_id, instruction_text)

That hook can assemble a deterministic list of required modules using the same versioned source you use for your skills; it avoids a model → load-skill → model round trip. The SkillsProvider implementation currently builds the skills catalogue and registers loading/resource tools, so caching discovery alone is not the same thing as eagerly including each skill's full body.

Two details I'd preserve in an always include feature: don't duplicate the full text when the same skill is later loaded, and keep scripts/resources lazy unless explicitly requested. Eagerly including instructions should not silently execute a skill's scripts or grant additional tools. It removes a round trip, but the included text still consumes input context/tokens. Which SDK/language are you using?

[Oisin Haken (VaclavK)]

Hi,

to start with, we are C#.

I ended up doing that - wrote a custom skills provider that preloads certain files and oninvoking returns that added content...

with this I no longer write them as full fledged skills are the discovery header part is no longer meaningful but that is just a choice I made and either could be true.

agreed re scripts and resources - that is not my concern (those are business skills really) but as a generic feature it makes sense.

I guess my main point was this probably could be a feature in MAF directly (in skills provider).

[Dimitri Pletschette (dmxplx)]

Hi Oisin Haken (@VaclavK), I ran into the same question while looking at the current skills implementation.

Based on what I found , for C#, your custom SkillsProvider approach seems like a reasonable way to preload known instruction files and avoid the extra discovery round trip. From the current design, though, the built in skills flow is mainly focused on discovery and loading, so an always include option does seem like a useful addition for this use case.

I found the skills design notes useful here:
https://github.com/microsoft/agent-framework/blob/main/docs/decisions/0037-agent-skills-design.md

Hope this helps. If this solved your issue, please mark this comment, or another relevant one, as the solution so that other users can see what worked. It would be highly appreciated.