Extend instructions after agent construction (but not using a dynamic instruction)

[baek54321]

Question

I have an application with multiple layers and functions. I create an agent with some instructions in one place and pass the agent through two layers of function until he is then actually called/used (e.g., run/run_sync is called).

Is there a way to extend the initial instruction when the agent has been created and not use the dynamic instruction (decorator) to do it? My issue with the decorator is that it gets re-evaluated multiple times when I ran several queries with the agent and that is creating a mess in the overall message history. I want the additional instruction being treated like the initial instructions added to the agent creation, except that I don't have the information at that time but a bit later.

I have also considered switching to system prompts as dynamic system prompts seem not to be re-evaluated but I am not sure this is the right way. Generally, instructions seem the right thing to use for my situation, I just don't have all the information at the time of agent creation (but before runtime via run/run_sync.

Thanks in advance for any suggestion!

Additional Context

No response

[DouweM]

@baek54321 You can wrap your agent.run call in with agent.override(instructions=...): to replace the instructions. Can you see if that works for you? We could also add an instructions arg to the run methods to add additional instructions to those configured on the agent.

[baek54321]

@DouweM thanks for the suggestion! Overriding all the previous instructions would not be so helpful. I am looking more for a way to add to the existing instructions. Adding an argument to the run methods for extending the initial instructions would be awesome and solve my use case.

Alternatively, a method to add or modify the instructions of an agent would also solve it but it seems that doesn't exist yet, or?

Thanks in any case!

[DouweM]

@baek54321 I think it could cause confusion about the state of the agent if instructions are added directly to it away from where it's defined, so I think an argument on the run methods would be most appropriate. Would you be up for filing a PR?

[baek54321]

@DouweM, I agree with you on the confusion aspect and to add it to the run methods. But I thought more about it and for our case, the instructions added to the run methods should be only temporary effective for the specific run where they are added to:

So that there would be the following options if we proceed with adding it like this:

• instructions during agent construction -> permanent instructions, used in every run of the agent
• agent.override instructions -> temporary replacement of all the existing instructions with something else
• dynamic instructions with decorator: permanent addition to the existing instructions which are re-evaluated and re-added for each run
• run method instructions: temporary addition to the existing instructions but only used / kept for a single run

What do you think? I can try a PR but it will take a bit as I have never contributed to such a big public project. :)

[DouweM]

@baek54321 Yep that's exactly how I imagine it working, and it's consistent with the other run method arguments. I suggest looking at how instructions are currently handled in Agent.iter, add the argument, get it to work, and then add it to all the other run methods that delegate to iter. Let me know if you have any questions!

[baek54321]

@DouweM , please have a look at my PR! I also adjusted the documentation and added a test. The functionality seems to work but the extension to the other run methods is not working properly. Would appreciate some guidance what I did wrong there :)