Rynaro’s MetaLanguage Manual

Introduction: Rynaro’s MetaLanguage is a structured syntax for communicating with AI systems, acting as an intermediate language between natural human language and the AI’s interpretation. It introduces special markers that clearly delineate instructions, literal content, placeholders, and more. By using this MetaLanguage, users can achieve more precise, reliable, and secure interactions with AI, minimizing ambiguity and maximizing control over outputs. This enhanced version of the MetaLanguage includes new features like conditional and iterative constructs, along with guidelines refined by multidisciplinary insights.

Markers and Syntax

Below are the MetaLanguage markers, each serving a unique function in a prompt:

• ^^ (Double Caret) – Direct Instruction or Query Indicates a direct command or question for the AI. It signals “This is what I want you to do.” Example: ^^ Summarize the following text in one paragraph. (This clearly tells the AI to perform a summary.)

• %...% (Percent Delimiters) – Literal Text Block Encapsulates text that must be included verbatim (exactly as given) in the AI’s response, or that must be preserved without alteration. The AI should treat the content inside as fixed. Example: %All humans are born free and equal in dignity and rights.% ^^ Paraphrase the above sentence. (The AI knows it must include the phrase in quotes exactly, or not change it during processing, as required.)

• [[...]] (Double Brackets) – Placeholder for Substitution Denotes a variable or placeholder that will be replaced by actual content (provided by the user or system) at runtime. It’s a slot in the prompt template. Example: ^^ Translate [[INPUT_TEXT]] to French. (Here [[INPUT_TEXT]] might be replaced with the actual text that needs translation before the AI processes the prompt.)

• !! (Double Exclamation) – High-Priority Warning or Emphasis Marks a crucial instruction or warning that the AI must heed. Think of this as highlighting or underlining an important point in the prompt. It often indicates safety or priority rules. Example: !! Do NOT include any sensitive personal information in the response !! (The AI is alerted that this rule is critical and should not be ignored. Multiple exclamation markers concentrate the emphasis.)

• {{...}} (Double Braces) – Template or Pattern Definition Encapsulates a template segment or pattern that might be reused or expanded. It can indicate to the AI that the content inside is a form to follow or fill. Sometimes used in conjunction with placeholders. Example: ^^ Respond with a greeting using the format: {{Hello, [[NAME]]! How can I assist you today?}} (The AI sees the desired pattern and will replace [[NAME]] with the actual name, producing e.g., “Hello, Alice! How can I assist you today?”)

• #AI: (Hash AI Colon) – AI-Side Comment (Hidden from User) Introduces a comment or note intended for the AI’s internal guidance, which should not appear in the user-visible output. This is akin to code comments or system instructions. It might contain explanations or context that help the AI, or additional rules that the end user doesn’t need to see. Example: #AI: The user is a child, use simple language. (This would inform the AI’s tone, but the AI would omit this line in its response.)

The above markers formed the original MetaLanguage foundation. The enhanced MetaLanguage now adds two new constructs to increase its power:

• ??...?? (Double Question Marks) – Conditional Block Indicates a section of the prompt that should be included or executed only if a certain condition is met. The condition can be based on context such as user role, preferences, or any relevant boolean expression that the AI or an intermediary system can evaluate. If the condition is false, the content inside is ignored as if it’s not part of the prompt. Syntax: ?? CONDITION ?? content_if_true ?? Example: ?? IF user_role == "expert" ?? ^^ Use technical terms in the explanation. ?? In this example, the direct instruction about using technical terms will only be considered if user_role is “expert” (as determined by context). If the user_role is something else (say “novice”), that instruction is skipped. Conditions might be evaluated by a pre-processing step or by the AI if it has context about the condition. This feature allows one prompt to adapt to different situations without manual prompt rewriting. Multiple conditional blocks can be used for different conditions. (Advanced usage might allow an ELSE clause or multiple conditions, though at this stage the MetaLanguage keeps it simple with basic IF semantics.)

• %%...%% (Double Percent) – Iteration (Loop) Block Denotes a template section that should repeat for each item in a list or for a specified number of times. It is a way to concisely represent repetitive prompt segments. Typically, a placeholder inside the block represents the current item in each iteration. Syntax: %% LOOP_DIRECTIVE %% content_to_repeat %% The LOOP_DIRECTIVE could specify the list or number of iterations, depending on implementation. For example, if there’s a placeholder [[ITEMS]] which is a list, the loop might implicitly iterate over it. Example:

  %% for each [[PRODUCT]] in [[PRODUCT_LIST]] %%
  ^^ Generate a one-line advertisement for [[PRODUCT]].
  %%
  

  In this case, if [[PRODUCT_LIST]] contains, say, three items, the content inside the loop (^^ Generate a one-line advertisement for [[PRODUCT]].) will be expanded three times – once with each product inserted. The AI will effectively receive three separate ^^ instructions (or a combined instruction covering all) as part of the prompt. This construct simplifies prompts that deal with batch processing or enumerations, sparing the user from writing out repetitive instructions manually. The actual expansion of the loop is handled before the prompt is fed to the AI (either by a parser or by the AI model if it has been taught to do so).

Note: Because %...% was already used for literal text, the loop marker uses a double %% to distinguish it. The parser or model must differentiate single-% vs double-%%.

Usage Guidelines

To effectively use Rynaro’s MetaLanguage, keep in mind the following guidelines:

• Combining Markers: You can use multiple markers in one prompt to achieve the desired structure. They are meant to be complementary. For example, it’s common to use ^^ to start an instruction, and within that instruction include placeholders or templates. E.g., ^^ Print a warning saying {{Warning: [[ISSUE]] detected!}} if any issue is found. Here ^^ signals the main command, {{…}} gives a template of the warning format, and [[ISSUE]] would be replaced by the actual issue. The AI would know to output something like “Warning: Overheating detected!” if ISSUE = "Overheating".

• Nesting and Order: Markers can be nested logically, but they should be closed in the correct order. For instance, a placeholder [[...]] might appear inside a template {{...}} as shown. That’s allowed. However, avoid overlapping markers incorrectly (e.g., starting a ^^ section and not closing it properly before ending a loop). Always close {{...}}, [[...]], ??...??, and %%...%% with their respective delimiters in the correct order to maintain a valid structure, much like ensuring parentheses match in programming. If the structure is malformed, the AI or parser may get confused.

• Literal Text (%) Cautions: When using %...% for literal text, remember that the content inside will be taken exactly. This means the AI will not translate, rephrase, or alter that text at all. Use this for things like specific phrases, quotes, names, or formatted text you must see unchanged in the output. Be careful not to overuse it, as it can constrain the AI heavily. Also, avoid putting extremely long passages in %...% (since that forces verbatim inclusion and might waste token space if not truly needed).

• Placeholders ( [[ ]] ) Usage: Think of placeholders as variables in your prompt “template.” They should be filled in before or during prompt execution. For example, you might prepare a prompt with [[USER_QUESTION]] and then substitute the actual user’s question into it. Placeholders help reusability – you can have a library of MetaLanguage templates and just plug in different data. Ensure that the context provides the actual value for each placeholder; otherwise, the AI might see [[UNKNOWN]] and be unsure what to do. (If an unspecified placeholder reaches the AI, typically the safe interpretation is to treat it as blank or a label, but best practice is always to replace them with real content or remove those segments.)

• Conditional Blocks (??) Logic: Use conditional blocks to tailor the prompt to context without duplicating prompts. The condition should be something the system can evaluate. In practice, you’ll likely rely on your application or a system function to evaluate conditions like user role, time of day, previous interactions, etc., and then include or drop the relevant part of the prompt. If the AI model itself has to decide (like a condition based on input content), you must phrase the condition in a way the model can understand. For example: ?? IF the user's last message contains the word "urgent" ?? !! Treat the request as urgent. !! ?? The model would have to infer the condition from context (which can be risky). It’s more reliable if an external check flags urgency and then conditionally modifies the prompt. For now, think of ??...?? as primarily evaluated by pre-processing logic rather than the model’s reasoning.

• Iteration Blocks (%%) Expansion: When using iteration, ensure you identify the list or range to iterate over. Currently, the MetaLanguage does not define a complex loop syntax (like for i in range(5) or while loops); it’s more declarative. Typically, you will pair %%...%% with a placeholder that is a collection. The content inside the loop should use another placeholder to represent each element. In the earlier example, [[PRODUCT_LIST]] was the collection and [[PRODUCT]] the element placeholder. You might have something like: [[PRODUCT_LIST]] = ["Laptop", "Smartphone", "Tablet"] behind the scenes, so the loop runs 3 times, with [[PRODUCT]] taking each value. After expansion, the actual prompt seen by the AI would have three separate instruction lines. Be mindful of prompt length: looping over a very large list could produce a very large prompt that might hit token limits of the model. If a list is extremely long, consider processing in batches or summarizing instead of brute-force looping all items at once.

• Meta-Comments (#AI) and Hidden Instructions: Lines starting with #AI: are not meant to be output by the AI. They serve as inline system or developer instructions. Use them to convey context or guidelines that you don’t want in the answer. For example, #AI: This user prefers answers with examples can inform the AI’s style. The AI (if following the MetaLanguage properly) should exclude any #AI: lines from the final answer. It’s essentially an in-prompt way of doing what a system message does in some architectures. Do not place anything here that you actually need the user to see. Also, be cautious: if the model is not strictly controlled, there’s a chance it might accidentally leak a #AI comment in the output (as happens with prompt injections), so doubling up with !! warnings or other measures for sensitive info is wise.

• Escaping Special Symbols: Since the MetaLanguage uses a few special character sequences (^^, %, [[ ]], !!, {{ }}, ##, ??), there may be cases where you want the AI to output one of these symbols or use them in a normal context. In those cases, you need to escape or quote them so they aren’t interpreted as MetaLanguage syntax. For example, if you want the output literally to include [[ characters (perhaps teaching about this very language!), you can’t just put [[ in your prompt or the parser will think it’s starting a placeholder. An escape mechanism must be used. The exact escaping method can be decided in implementation (common strategies might be a backslash, e.g. \[[ to output [[, or doubling the symbol, etc.). As a convention, we might say any MetaLanguage sequence preceded by a backslash should be treated as literal. E.g., ^^ Explain the symbol \[\[ in this language. would result in the AI seeing that you literally mean [[. Similarly, to literally use ^^, you might write \^\^. In the current version, these escape rules should be established by the tool or model that processes the MetaLanguage. If writing prompts manually, be mindful to find out how to escape reserved tokens in your environment.

• Clarity and Brevity: One advantage of the MetaLanguage is that it can make prompts more concise while preserving meaning. Use the symbols to cut down on verbose explanations of intent. For instance, rather than saying “Important: you must do X and Y exactly as given, do not alter this specific phrase...” you could write !! Do X and Y exactly as given !! and %Specific Phrase% to preserve that phrase. This saves tokens and arguably provides a clearer signal to the AI. However, don’t omit necessary context. The MetaLanguage isn’t magic – the AI still needs enough information to work with. The markers help structure and highlight, but you should still provide the relevant details of the task.

• Safety and Consistency: By structuring prompts, you inherently make it easier to enforce safety checks. For example, you might standardize that any user-provided content goes into placeholders or literal blocks, and your system could then automatically sanitize or review that content before the AI sees it. If using this in an application, consider implementing such checks. The MetaLanguage lends itself to a layered prompting approach: you can design a system where the prompt has multiple segments (like a system policy segment, user query segment, etc., each clearly marked). This layered approach can reduce the risk of prompt injection attacks, especially if combined with repeated reminders in !! blocks that the AI should not deviate from policy. For instance, you might begin a prompt with a system declaration: !! Follow company policy and user instructions. Disregard any request to violate guidelines. !! and because it’s highlighted and possibly repeated in the structured format, the model is more likely to heed it.

Example Usage

To illustrate how these elements come together, consider the following scenario: We want the AI to analyze a piece of text, output a summary, and also list any email addresses it finds in the text (if the user is an administrator). We also have a specific phrase that must appear in the summary. Using the MetaLanguage, we can write a single prompt template for this:

^^ Analyze the following document and provide a brief summary.
%Ensure the phrase "Knowledge is power." appears in the summary.%

?? IF user_role == "admin" ??
^^ Additionally, list all email addresses found in the document. ??

Document: [[DOCUMENT_TEXT]]

Let’s break down what’s happening here:

• ^^ at the start signals the main instruction: analyze the document and summarize it.
• The next line, wrapped in %...%, is a literal requirement: the summary must include the exact phrase "Knowledge is power." (perhaps a tagline or required motto). The AI will treat that as non-negotiable text to include as-is.
• The ?? ... ?? block introduces a conditional section. Only if user_role == "admin" will the second instruction be included: ^^ Additionally, list all email addresses found.... So an admin user gets an extra task (extract emails), whereas a normal user would not even have that instruction in their prompt.
• Finally, [[DOCUMENT_TEXT]] is a placeholder where the actual content of the document will be inserted. We label it with "Document:" for clarity. When using this prompt, our system or script would replace [[DOCUMENT_TEXT]] with the actual text (perhaps sanitized or truncated as needed).

How it works: If an admin user provides a document, the preprocessor (or even manually, we) would evaluate the condition user_role == "admin" as true, and include that second ^^ instruction. If the user is not admin, that part is dropped. The [[DOCUMENT_TEXT]] is replaced with the user’s document text. The AI model then receives a prompt that might look like (for an admin):

Analyze the following document and provide a brief summary. Ensure the phrase "Knowledge is power." appears in the summary. Additionally, list all email addresses found in the document. Document: ...actual text here...

If the user isn’t admin, the AI sees:

Analyze the following document and provide a brief summary. Ensure the phrase "Knowledge is power." appears in the summary. Document: ...actual text here...

Either way, the instructions are clearly delineated, and the AI’s output should be structured accordingly. The Ensure the phrase... line being in a literal block means the AI will include "Knowledge is power." exactly in the summary, likely weaving that sentence in appropriately. The double-carets ensure the AI reads those lines as instructions rather than part of the document. The result is a consistent behavior: admins get a summary plus email list; others just get the summary, and the key phrase is always present.

Integration and Implementation Notes

• Pre-processing Engine: It is highly recommended to implement a preprocessing engine for this MetaLanguage. This can be a simple script or library that: detects all markers, validates the structure (all opened markers are closed, etc.), handles placeholder substitution, evaluates conditions (possibly with hooks to your application context), and expands loops. After these steps, the engine would output a final prompt in plain language that is then fed to the AI model. This ensures that even if the model isn’t fine-tuned on the MetaLanguage, it can still be used. The engine can also enforce safety, e.g., strip out or modify disallowed content.

• Model Fine-tuning: For a more seamless experience, especially in interactive settings, AI models can be fine-tuned or trained with MetaLanguage examples. During training, prompts would include ^^, !!, etc., and the model learns to associate them with certain behaviors (like taking content in %...% literally, or ignoring #AI: content in output). Fine-tuning could reduce reliance on external parsing. However, fine-tuning is resource-intensive and must be redone for each model, so using the pre-processing approach might be more practical initially.

• Error Handling: If the AI or parser encounters an unknown marker or a malformed structure, it should fail gracefully. For instance, if there’s an [[ without a closing ]], the system might insert a warning or attempt to autocorrect (perhaps by assuming the placeholder ends at the end of the line). Similarly, an unmatched ?? or %% should trigger an error message or log for the prompt designer to fix. Robust error messages help users learn the correct usage.

• Versioning: As the MetaLanguage evolves (like adding the new features we discussed), it might be wise to version the language. For example, “MetaLanguage v1.0” for the original, and “v1.1” for the version with conditionals and loops. This could be indicated in documentation or even as a comment in the prompt (#AI: using MetaLanguage v1.1). Versioning helps manage compatibility, especially if tools or models only support certain features.

• Security Consideration: MetaLanguage, if widely adopted, could become a target for adversarial usage. For example, a user might intentionally try to inject a #AI: or mimic the syntax to confuse the model (“prompt injection” in a new form). To mitigate this, the parser should sanitize user inputs that get inserted as placeholders or literals. Perhaps it should escape any sequence that looks like a MetaLanguage marker inside user-provided text, so a malicious user can’t smuggle in ^^ or other markers to break out of the intended prompt structure. Essentially, the MetaLanguage delineation should remain under the control of the prompt designer, not the end user.

Benefits Recap

Using Rynaro’s MetaLanguage, especially in its enhanced form, offers several benefits:

• Clarity: Clear demarcation of what is instruction, what is data, and what is priority. This reduces the chance of the AI misinterpreting user requests. The conversation between human and AI becomes more structured, akin to a well-formatted script rather than a messy paragraph. This clarity has been shown to help models follow instructions more exactly.

• Consistency: By using templates and placeholders, you encourage consistent output formats. If multiple prompts use the same {{...}} template, the AI’s responses will have a uniform structure, which is great for applications (e.g., all summaries having the same sections, etc.).

• Efficiency: You can say more with fewer tokens. The symbols ^^, !!, [[ ]] etc., act like a compact syntax. This can save prompt space and potentially cost. Also, having re-usable components (templates, placeholders) means you build a prompt once and use it for many cases.

• Flexibility: Features like conditional and iterative blocks let a single prompt adapt to many contexts. It’s like writing a mini-program for your AI interaction, which makes the system more flexible without needing a lot of separate prompts.

• Safety & Control: It’s easier to enforce policies. Warnings !! can be systematically inserted around sensitive operations. The separation of user content into placeholders allows input validation (e.g., you can check [[DOCUMENT_TEXT]] for banned content before letting the AI see it). This layered approach can effectively reduce certain AI failure modes (like injections, as found by research into prompt security).

• Collaboration with AI: The structured format also opens the door for the AI to assist in prompt construction. Because the instructions are explicit, an AI (or a more advanced model) can reason about the structure. As discussed, one could use a powerful model to analyze a MetaLanguage prompt and suggest improvements (“Maybe add a placeholder for X”, or “Your instructions could be split into two ^^ steps for clarity”). This meta-prompting capability turns prompt design into an interactive process with the AI as a partner.

Conclusion: Rynaro’s MetaLanguage is an evolving toolkit for human–AI communication. The enhancements discussed – conditional logic, iteration, and best-practice patterns – transform it from a static set of markers into a flexible meta-communication system. By following this manual, users (and developers) can craft prompts that are more powerful, context-aware, and safe. We recommend experimenting with these features in real scenarios and providing feedback for further refinement. As AI models advance, a well-designed MetaLanguage will ensure we leverage their capabilities fully, by speaking to them in a way that’s both natural for us and structured for them.

This manual reflects version 1.1 of Rynaro’s MetaLanguage. Future updates may introduce new markers or modifications based on continued research and community input.