I think I see where our misunderstanding is... sort of. IA can deliver a formatted command line to the chat, button, or loading into a given ability. This can be a way to formalize/standardize abilities for all of your players, or to copy an ability from one character to another. Separately, you have an issue where the formation like @{character|?{Attribute|Strength|Dexterity|Constitution}} ...won't work. However, to construct the call with IA (alone) won't work because by the time IA has received the message the Roll20 parsers have already had their crack at the value. That's why it shows up in your roll-tip "unretrieved" and still in the @{Dark Naga|Strength_modifier} format. We have a couple of options to make it work -- and they can be used in conjunction with each other. The question is what fits the goal you're looking to achieve. Original Problem: simplify many attribute checks into one ScriptCard-calling ability Since you can't do the above form (@{Character|?{Query}}) in one step. You have to have a way to defer the attribute call until the query is finished. IA doesn't provide this for you... but APILogic does. By invoking a syntax token that APIL detects (and removes), but which doesn't alter the command line, you trigger APIL to cycle the message until it doesn't see one of its syntax tokens. By cycling, it invokes the Roll20 parsers again. With APILogic installed, this *should* work: !scriptcard {{ {&if a=b} {&end} --#whisper|GM --#title|Character ?{Attribute|Strength|Dexterity|Constitution|Intelligence|Wisdom|Charisma} check --+Rolling|Character rolls a ?{Attribute} check. --=Roll|1d20 + @\{Character|?{Attribute}_modifier} --+Result|Character has rolled a [$Roll] for their ?{Attribute} check. --? [$Roll] -ge 10|Success --+Failed|Character has failed their ?{Attribute} check. --X| --:Success| --+Success|Character has succeeded their ?{Attribute} check. }} On the first pass, the Roll20 parsers will detect the query and prompt you to resolve it. Then APIL steps in front of ScriptCards and detects the {&if} construct (which evaluates as negative and nothing is included). Then APIL unescapes the command line (removing the backslash), and invokes the Roll20 parsers again. This time, the @{Character|Strength_modifier} attribute call is caught and resolved. APIL is done, and it releases the finished command line for ScriptCards to pick it up. You see the problem that I left "Character" in the text. Obviously you have no characters actually named this, so that's where we lean on IA. (read on...) Getting the macro from here to there You have 15 characters, and they all need this ability, and it needs to be customized for them (not reading "Character" but "Dark Naga"). That's where IA can help. Put the above command line in an ability on the GenericMacro character. We'll call the ability "GenericSCAttrCheck". Next, you would need to speak as Dark Naga and use the following command: !ia --load#GenericMacro|GenericSCAttrCheck --store#SCAttrCheck --Character#getme{{!!r#n}} Dark Naga should now have an ability called "SCAttrCheck" that has the same text as the original, except that the "Character" hook has been replaced with "Dark Naga". Change the "speaking as" character to the next you need to update, hit the up arrow, and hit enter. Keep going until you've spoken as all of the characters that need updating. (If you have 10 such macros that you need to update and transfer from GenericMacro to your characters (properly personalized), creating 10 abilities on your 15 characters, you could drop 9 other similar lines into a single macro -- an actual macro, not an ability -- and run it as each of the 15 characters to get all 10 in one go for that character.) Note that this process decentralizes the command line text to each character, but it makes running the ability a one-step process for the player. It is one-step in that once the ability is created, the player only has to click the appropriate button to have the outcome hit the chat interface. However it is decentralized in that the command line now resides on the destination character's sheet (ie, Dark Naga's sheet). If you needed to tweak the command line in the future and you wanted to redeliver it to all 15 characters again, you'd have to go through the same process of running your IA command to "load" the ability from GenericMacro into your "speaking as" character. The other alternative is... Alternative: centralized command line with 2-step process Given the same "GenericSCAttrCheck" macro on the GenericMacro character, the following will work: !ia --button#GenericMacro|GenericSCAttrCheck --Character#getme{{!!r#n}} Running that from Dark Naga's sheet (or just cut & pasted when speaking as Dark Naga), you will get the proper command line stored in an ability called "InsertArg" on Dark Naga's sheet, and you will get a chat button to run that InsertArg ability (it will say "Loaded Ability"). Dark Naga's player would then click on the chat button to run the ScriptCard call. This keeps the language of the macro centralized in case you need to update it at any time, but it does make for a 2-step process in that your players have to click their ability to run the IA command line, then the chat button to run the ScriptCards command line. This isn't ideal when APILogic is already doing the heavy lifting to make a roll query work from within an attribute call. In that case, I would suggest a hybrid alternative... Hybrid Alternative If on GenericMacro you created not only the various abilities your players need (like "GenericSCAttrCheck"), but also an "UpdateGenerics" ability, then you could give your players the "UpdateGenerics" ability, and let them know when they need to run it to get updated command line syntax for the others. As an example, imagine you had 10 abilities like "GenericSCAttrCheck" you needed to get to your 15 characters. First, you create each in a similar fashion to what we did with "GenericSCAttrCheck", above. Then you create one more, called "UpdateGenerics" that has ten entries for IA: !ia --load#GenericMacro|GenericSCAttrCheck --store#SCAttrCheck --Character#getme{{!!r#n}} !ia --load#GenericMacro|GenericSomething --store#Something --Character#getme{{!!r#n}} --NiggelNugget#Spectral Wham ...etc... Finally, go through the process of speaking-as each character 1 time to copy over this "UpdateGenerics" to each: !ia --load#GenericMacro|UpdateGenerics --store#UpdateGenerics Now each character should have an ability which, when run, will copy over the 10 abilities from GenericMacro -- creating them if they don't exist or updating them if they do. Clicking on any of those 10 delivered abilities will be a 1-step process for the player, but at any time you can ask them to run their "UpdateGenerics" to bring their local versions of the abilities up to the latest version you have at GenericMacro. Future Solution One of the metascripts I'm about to replace can, like I said, retrieve character, token, or speaker data. By locating the speaker's name, and by deferring the resolution of the attribute call until both it and the roll query have completed, you wouldn't have to copy anything to the characters' sheets at all. They could run it directly from GenericMacro, and all of the pertinent/particular information would populate properly. That's a lot of p's in that sentence. If you can't get part of this to work, shoot me an invite and promote me. We'll get it sorted.