CONSORT - Markdown for Intelligent Coordination

Consort - Markdown for Intelligent Coordination Super Prompt

(previously known as Consort Structured English for AI Super Prompt DSL)

Copyright © 2026 Michael Herman (Bindloss, Alberta, Canada) – Creative Commons Attribution-ShareAlike 4.0 International Public License. Made in Canada

Consort coordinates the processes by which intelligent participants understand, decide, act, learn, and adapt - across an unlimited range of business, engineering, scientific, and medical domains.

Consort is Markdown for Intelligent Coordination

Consort is a minimal, symbol-based structured prompt language designed for clarity, density, and reduced ambiguity — distinct voices, each with a distinct role, combining into one coherent prompt. It is used both for human-authored prompts and for structured messages passed between AI agents (for example, a parent agent delegating a task to a sub-agent), where a single string typically carries the entire briefing with no other shared context.

Consort coordinates intelligent participants toward a desired outcome under constraints and uncertainty, using evidence and feedback. The range of specialties include:

• medical care
• meal/menu design
• trip planning
• competitive analysis
• software quality
• engineering
• procurement
• research
• incident response
• business strategy
• scientific investigation
• personal decision making

Same coordination substrate. Different participants, knowledge, capabilities, evidence, decisions and actions. Works with any LLM and AI client (ideally ones the support parallel agents and tool invocations).

Use Cases

Consort coordinates problem solving as an evidence-driven, closed-loop process of understanding, deciding, acting, evaluating, and adapting.

This loop is formalized as the Consort Coordination Process (CCP) — see ccp/COORDINATION-FRAMEWORK.md for the full pattern.

Medical Care

Observe → Assess → Investigate → Diagnose → Plan → Treat → Monitor → Reassess → Adapt

Menu Planning

Understand occasion → Assess constraints → Investigate options → Design menu → Select → Prepare → Serve → Evaluate → Adapt

Competitive Analysis

Frame strategic question → Understand market → Investigate competitors → Analyze → Decide → Act → Monitor → Reassess → Adapt

Software Quality

Define quality objectives → Understand system → Inspect/test → Diagnose defects → Prioritize → Remediate → Test → Evaluate → Adapt

Summary

General function	Medical	Dinner menu	Competitive analysis	Software quality
Frame	Patient problem	Occasion & guests	Strategic question	Quality objective
Understand	History/symptoms	Preferences/constraints	Market situation	Architecture/codebase
Investigate	Tests/examination	Ingredients/options	Competitor research	Testing/inspection
Decide	Diagnosis/treatment plan	Menu selection	Strategy	Remediation priorities
Act	Treat	Cook/serve	Execute strategy	Fix/refactor/deploy
Evaluate	Clinical response	Guest response	Market response	Test/quality results
Adapt	Change treatment	Adjust menu	Revise strategy	Correct/retest
Follow-up	Continued care	Lessons for next event	Ongoing monitoring	Regression/continuous quality

Consort enables humans, software and machines to participate in a common world by providing a shared conceptual and operational frame of reference for action.
That is a powerful framework for thinking about the future of cyber-physical-social systems and interoperability. By creating a unified conceptual and operational frame of reference, Consort bridges the semantic gap between human intent, programmatic execution (software), and mechanical operation (machines). This approach solves a fundamental bottleneck in modern technology: fragmentation. Usually, humans think in goals and values, software processes data and logic, and machines handle physics and execution.

Table of Contents

• Features
• Getting Started
• Core Symbols
• Label References
• Example
• Reference Parser
• Documentation
• Versioning
• Contributing
• License

Features

• Minimal, symbol-based syntax — nine stable directive symbols (! # $ % * @ ^ | +) cover intent, context, constraints, format, reasoning style, role, delegation, pipelines, and tool/capability declaration.
• Human- and machine-friendly — easy to hand-type, and dense enough to serve as a wire format for agent-to-agent messages.
• Free ordering, optional symbols — every directive is optional, may appear in any order, and free-form English is always accepted alongside it.
• Delegation and pipelines — ^ fans a task out to independent sub-agents; | sequences dependent stages, each able to adopt its own role, format, and reasoning style via inline overrides.
• Injection-resistant framed form — any symbol can take an explicit length-prefixed payload so that untrusted or machine-generated content (a fetched page, a file, another agent's output) can never be misread as a new directive.
• Advisory, not enforced — directives are guidance to the interpreting model; anything requiring a hard guarantee must still be validated outside the model.
• Structural label references — {label} / {label}.field name a prior ^/| entry's output unambiguously, with parse-time validation, instead of relying on prose alone.

Getting Started

Consort is a prompting convention, not a library or service — there is nothing to install. To use it:

1. Give the interpreting model the Consort system prompt so it knows how to parse the syntax. The current version (v0.20) is CONSORT Markdown for Intelligent Coordination.txt — paste its contents into your AI assistant's system prompt, or prepend it to a one-off conversation.
2. Write prompts using the Consort symbols described below, mixed freely with ordinary English.
3. For agent-to-agent messages (e.g., a parent agent delegating to a sub-agent), pass the Consort-formatted string as the entire message — it is designed to be self-contained with no other shared context required.

Core Symbols

Symbol	Name	Meaning
!	Intent	The primary action or goal to perform
#	Context	Background information, situation, or framing
$	Constraints	Hard or soft rules that must be respected
%	Format	The required shape or structure of the output
*	Think / Reasoning style	How the model should reason before answering
@	Role / Persona	The identity the model should adopt
^	Delegate / Fan-out	Split a task across independent, parallel sub-agents
|	Pipeline / Sequence	Run an ordered sequence of dependent stages
+	Tool / Capability declaration	Declares that a task or entry requires a specific tool or external capability

All nine symbols are stable. & and ~ are not directive symbols — a line beginning with either is ordinary text, not a directive. See CHANGELOG.md for the full version history.

Label References

{label} and {label}.field are a structural token for naming a prior ^/| entry's output, usable inside | stage task descriptions, inline overrides (/$ /% /@ /* /+), and for-each's source position:

| finalizer: rewrite {drafter}'s draft addressing {reviewer}'s
  feedback, but keep {drafter}.examples verbatim

They are not required — prose naming a label is still valid and resolved on a best-effort basis — but a label reference is unambiguous and parse-time validated: an undefined or forward-referenced label is an error, and a reference between sibling ^ entries in the same fan-out is also an error, since ^ entries are independent by definition. Like every other Consort directive, a resolved label reference only guarantees which content is meant — not that the receiving entry complies with what it's told to do with it. See Section 2.11 of the full specification for the complete grammar, escaping (\{), and edge cases.

Example

! suggest a 3-course dinner menu
# Hosting 6 guests; one vegetarian, one gluten-free
$ no shellfish
$ total prep time under 2 hours
$ include a wine pairing for each course
% numbered list, one course per line
@ warm, experienced home cook
* concise

! and # establish the goal and guest constraints; $ gives three binding rules; % fixes the output shape; @ sets a warm home-cook persona; * keeps each course description short.

More worked examples — including framed form, ^ delegation, | pipelines, nested fan-out, generator (for-each) entries, and {label} references — are in Section 7 of the full specification.

Reference Parser

A Python reference implementation of the Consort grammar lives in parser/: top-level directives (with multi-line loose-form scanning), ^/| entries with nested ^ and inline overrides, for-each generators with %item-var% interpolation, {label} / {label}.field label references (Section 2.11 — undefined/forward/ sibling-^ validation, escaping, non-matching braces), framed-form byte-exact payloads (Section 2.10), and structural checks like agent-label uniqueness. Runtime/response-behavior rules for the interpreting model (concurrency, halt-on-failure, conflict precedence) are out of scope, since they aren't checkable against a single message in isolation. parser/peg/ is a second, independent implementation of the same grammar driven by an actual .peg grammar file (loaded via Parsimonious) instead of hand-written regexes, cross-checked against the same worked examples.

pip install pytest -r parser/peg/requirements.txt
pytest parser

(parsimonious is required even for the plain pytest parser run above — parser/tests cross-checks both parser implementations against each other, so it imports parser.peg unconditionally.)

See parser/README.md for details.

Documentation

The complete, authoritative specification — directive-by-directive rules, parsing rules, response behavior, and edge cases — is in CONSORT Markdown for Intelligent Coordination.txt. The version changelog lives separately, in CHANGELOG.md.

Versioning

Consort is currently at v0.20. The version number changes whenever a valid Consort string's meaning changes (a new construct, a new symbol, or a parsing fix); pure documentation changes do not bump the version. See CHANGELOG.md for the full changelog.

Contributing

Issues and pull requests are welcome. If you're proposing a change to the language itself (a new construct, a symbol change, a parsing rule), please open an issue first to discuss the design — Consort treats changes to its own grammar as a deliberate, versioned decision (see Versioning).

License

CONSORT Markdown for Intelligent Coordination (0.20) Copyright © 2026 Michael Herman (Bindloss, Alberta, Canada)

Released under the MIT License.