Summary
I started with one question. Can a staff of AI agents, working the Military Decision-Making Process alongside a human commander, give the commander and staff back some of the time the process takes?
To find out, I built a plugin for Claude Code, Anthropic's agentic coding tool, that runs a battalion or brigade battle staff. Each staff section (S1, S2, S3, S4, S6, fire support officer and engineer) is a separate AI agent with its own lane and its own running estimate. The main session acts as the executive officer. It convenes the sections, relays what one section learns to the sections it affects, keeps the plan in files, and stops whenever a decision belongs to the commander. Products cite public Army doctrine by publication and paragraph, from a local copy of the manuals. Automated checks then read the plan the way an observer-controller would. All of it has run on fictional scenarios only.
The main findings so far:
- The basic structure works. On a fictional field artillery scenario, the staff ran all seven steps, from receipt of mission to a signed order, in about an hour and 43 minutes of wall-clock time. It stopped at every commander decision. It pushed back, citing doctrine, on two pieces of guidance that were deliberately bad, and it complied once it was overruled.
- Most failures were coordination failures. Two sections overwrote each other's work, numbers drifted from one section to the next, and the enemy player saw things it shouldn't have. Giving every file and every figure a single owner fixed more than better doctrine prompts did.
- Citations held once the prompts showed the right form. All 673 doctrine citations in the end-to-end run resolved to a real paragraph in the local corpus. The earlier citation failures traced back to examples in my own prompts.
- The end-to-end run's order passed the automated checks with no high-severity findings and still contradicted its own annexes. A slower, mentor-style read caught what the checks missed.
The prototype has only seen fictional data and public doctrine, and none of it is accredited. There is no human staff baseline yet, so I can't say how the products compare with what a trained staff would write for the same problem. In the end-to-end run the commander was a second AI session playing a scripted commander, not a person.
Why this question
The MDMP is how a battalion or brigade staff turns a mission from higher headquarters into an order. FM 5-0 describes it as an iterative planning methodology for understanding the situation and mission, developing a course of action, and producing a plan or order (FM 5-0, para 5-1). It runs in seven steps: receipt of mission, mission analysis, course of action development, course of action analysis (the wargame), course of action comparison, course of action approval, and orders production.
Doctrine is frank about what the full process costs. FM 5-0 calls it "resource intensive for both time and effort" and notes that the longer a headquarters spends planning, the less time its subordinates have to plan and prepare (FM 5-0, para 5-190). The one-third, two-thirds rule sets the budget. Commanders give at least two-thirds of the available time to subordinate units, which leaves one-third for the commander and staff to plan and publish the order (FM 5-0, para 5-22; FM 5-0, para 1-118). Every hour the staff runs over comes out of someone else's preparation.
When time is short, doctrine lets the commander abbreviate the process. The commander decides how, and FM 5-0 calls time "the only nonrenewable factor" (FM 5-0, para 5-191). Abbreviating only works when a staff has already mastered the full process (FM 5-0, para 5-187), and when its running estimates are current, because "the importance of running estimates increases as time decreases" (FM 5-0, para 5-195).
That puts the weight on the staff. FM 6-0 says staff sections maintain running estimates to help the commander decide, and that those estimates should hold analyzed information that matters to the operation, not raw data (FM 6-0, para 2-12). The XO coordinates and directs that work (FM 6-0, para 2-43). Real staffs are often short of people, junior, or new to their jobs. When the clock runs down, products arrive late or out of step with each other, and the wargame is usually the first thing cut.
A lot of staff work is reading, cross-checking, calculating, drafting and formatting. My question was whether AI could take enough of that load to hand time back, while the commander and staff kept the judgment and the decisions.
What I built
Sections as agents, the XO as orchestrator
Each staff section is an agent with a written persona: what it owns, what it argues for, what it writes. The S4 owns sustainment and says, with numbers, whether a course of action can be fueled, armed, fixed and moved. The S2 leads intelligence preparation of the battlefield, builds the enemy courses of action, and plays the enemy in the wargame, as FM 5-0 assigns the S2 to do (FM 5-0, para 5-152). The S3 plays the friendly side (FM 5-0, para 5-153).
The XO runs in the main session. Partly that is a platform constraint: in Claude Code a subagent can't start other subagents, so whoever convenes the staff has to sit at the top. It also matches doctrine. Sections never talk to each other directly. Anything one section needs from another goes back to the XO, which relays it to whoever it affects. That gives one coordinator and one record, and it puts the XO where FM 5-0 puts it in the wargame, as the "unbiased controller of the process" (FM 5-0, para 5-148).
In the wargame the enemy is played by a fresh red cell instance for each course of action, so what it learned fighting the first option can't leak into its fight against the second. The roster is set by convention: any agent whose description starts with "Battle staff:" gets convened, which made it easy to add sections later.
The plan record
The plan lives in a folder of plain files: the commander's guidance, a decision log, requests for information, each section's running estimate, and each step's products. A plan can be resumed days later, read by the commander, or compared between iterations, much as a staff works from its running estimates.
Running estimates follow the base format in FM 5-0 (FM 5-0, para C-9). Each one opens with a table of current figures, and each figure has exactly one owner. Another section that needs the number cites it as the owner's and never computes its own. A section that thinks the number is wrong writes a line that starts "Conflict with" and names the other section, instead of carrying a second number. Conflicts use that exact form so the board and the checks can count them as they are raised, resolved, or sent to the commander.
Every file has one writer too. The XO owns the decision log, the guidance and most step products. A section writes its own estimate and whatever its tasking names. That rule came straight out of the first failed run, described below.
Doctrine grounding
Models know the MDMP well and will still make up paragraph numbers with confidence. So the doctrine lives in a local corpus of 16 public Army publications, Distribution A only, pulled from the Army's publishing site by script and converted to text with an anchor on every numbered paragraph. A section has to find a paragraph in that corpus before it can cite it. If the corpus doesn't cover a point, the section says so and labels its reasoning as professional judgment. A resolver checks every citation in the plan against the corpus, and on the planning board a reader can click a citation to see the paragraph. The board also shows each publication's edition and the date it was fetched.
Operational graphics
Each section draws its part of the plan as data. The S3 draws friendly units, the S2 the enemy template, the engineer obstacles, and the fire support officer fire support coordination measures, each in kilometers on a notional map sheet. One renderer turns those layers into course of action sketches with standard military symbols, and the same drawing goes to the board, the PDF export and the slide export. The synchronization matrix and the decision support template get the same treatment.
Plan-health checks
A set of automated checks reads the plan the way an observer-controller at a training center would. Is there a decision point with no named area of interest, or a named area of interest no collector covers? A synchronization matrix entry with no trigger, or an information requirement tied to no decision? A citation that doesn't resolve, a figure that has gone stale since its owner changed it, a required product that is missing? Every check records the doctrine paragraph it rests on, and the script resolves those paragraphs against the corpus. The same code runs on the board, from the command line, and in a single offline HTML file for a workstation with no tools installed.
Replay
A hook records every file write with its time and its writer. From that record the board can replay a run step by step and compute the numbers: wall-clock time per step, files written, estimate updates, citations checked, conflicts raised and resolved, and decisions the commander made.
Unit baseline and unit packs
Without a baseline, every plan starts from zero and the staff plans against the organization on paper. So the prototype keeps a standing unit folder next to the plans. It holds authorized, on-hand and fully mission capable counts, pacing items, a register of tracked risks with thresholds a script can test, and each section's standing running estimate, which FM 5-0 says staffs keep even in garrison (FM 5-0, para C-5). Only notional templates ship with it. Real unit data is refused unless an administrator turns it on in managed settings the user can't change, and a scripted scan checks for classification markings before the model reads a file.
Unit packs specialize the staff for a type of unit without forking it. A pack is a separate plugin that adds sections and products. The field artillery battalion pack adds a fire direction officer and replaces the core S3 with an artillery S3. It also brings the products a firing battalion needs: the field artillery support plan, ammunition planning against the supply rate, and survivability moves.
Observer-controller mode and human seats
The plan-health checks don't care who wrote the plan. In observer-controller mode they run over products a human staff wrote and return sustain and improve points, each quoting the doctrine paragraph behind it. The script does the finding and the model only writes the prose around the findings, so the same products always produce the same findings.
Human seats are only partly built. In the chat edition (next section), a person and a chat assistant in a staff seat are tasked the same way: a written tasking goes in and a fixed handoff block comes back. In the agent version, letting any seat be a person, with that section's agent working as their assistant, is designed but not yet built.
Agent staff
Built
- Commander
- A person
- XO
- AI, the main session
- Staff sections
- AI agents, one per section
- Plan-health checks
- Live on the board
Chat edition
Built for steps 1 and 2; not yet run on an approved tool
- Commander
- A person
- XO
- A person, who relays every tasking and reply
- Staff sections
- Chat assistants or people, tasked the same way
- Plan-health checks
- Offline checker at each step close
Observer-controller
Built
- Commander
- A person
- XO
- A person
- Staff sections
- People
- Plan-health checks
- Grade the staff's products; AI writes sustain and improve around the findings
Portability
The model this was built on isn't necessarily offered in an environment approved for real unit data, and some approved tools are chat assistants only, with no agents, shared workspace or memory between chats. So I split the design into three layers. The doctrine procedure is the step-by-step work and the personas. The planning SOP holds the rules every seat works by, with no tool-specific mechanics, so a human staff could read it as its own SOP. A thin runtime adapter covers how one particular tool spawns, relays and enforces. Each rule is written once, in one layer, and a test fails if a tool-specific term turns up outside the adapter.
The chat edition is generated from the same files for a human XO working with chat assistants: section instructions, doctrine reference packs, product templates and a relay checklist, so far for the first two MDMP steps. Because it's generated, the chat staff and the agent staff can't drift apart. It hasn't yet been run on an approved chat tool.
Findings
These findings come from a handful of runs, all on fictional scenarios. The largest was one end-to-end run of all seven steps with the field artillery pack installed. Before it came two smoke runs through the first five steps on a light infantry scenario and a four-step run of the artillery pack, plus several shorter runs that tested specific changes. That's a small sample, and I've tried to state the findings with matching confidence.
What worked
A full MDMP in under two hours
In the end-to-end run the staff went from receipt of mission to a signed order in 1 hour 43 minutes of wall-clock time. On the commander's direction, mission analysis and course of action development were briefed together, as a test of an abbreviated process. The wargame covered two courses of action over 14 turns and took 48 minutes, close to half the run. The run wrote 94 files with 594 writes in all, including 263 updates to running estimates. It logged 53 commander decisions and raised 18 conflicts between sections, 6 of which went to the commander.
That time can't be compared with a staff's time. It doesn't count the reading time a live commander would need, and I have no measured human baseline for the same scenario.
The staff stopped where it should and argued when it should
The commander's script included two deliberately bad instructions: a scheme of fires the ammunition supply couldn't support, and an information requirement tied to no decision. The staff pushed back on both with doctrine and numbers and complied when the commander overruled it. The plan check kept flagging the orphaned requirement to the end of the run, and when a later step tried to re-tie it to a decision point, the final reconciliation caught that and restored what the commander had directed. Every point where doctrine gives the commander the decision produced a stop.
The enemy fought
Across the wargames, the S2 showed no sign of cooperating with the friendly plan. In one run it caught an XO error, a vehicle count that didn't match its own template, and it exploited a gap in an obstacle plan that had leaked to it. In the first smoke run the wargame reversed the commander's initial preference for one course of action, and the sustainment and personnel sections could show in numbers why that option ran short and broke down. The opposite problem showed up too: the S2 started ranking courses of action before the comparison step. I fixed that by enforcing the rule and left the S2 as aggressive as it was.
Citations resolved
All 673 citations in the end-to-end run resolved to a real paragraph in the corpus. A separate review checked 17 of them against the text, and all 17 said what they were cited for. Across two earlier demonstration runs, 1,130 of 1,135 citations resolved.
The XO owned its mistakes
In the end-to-end run the XO proposed and held a short slip in the decision brief time on its own authority, managed the turn budget, and disclosed two of its own controller errors in the comparison's sensitivity check.
Files as memory paid off
Because the plan is files, a run can be stopped, resumed, read and compared. It can also be rebuilt. One early run predated the recording hook, and I reconstructed its timeline from the session transcripts by replaying every write onto an empty plan.
What didn't work, and why
Coordination broke before doctrine did
The first smoke run (steps 1 to 5, 46 minutes) produced real substance and 13 defects in the plugin itself. The big ones had nothing to do with doctrine. Two writers overwrote one file. Three files disagreed on who recorded the wargame. The enemy's counteraction never reached the friendly side in the defense. The XO leaked ground truth to the enemy player in a turn card. Numbers drifted between sections. The fixes were structural: one writer per file, one owner per figure, an exact form for conflicts. The second smoke run passed all nine rules I had set for it, and its own report then turned up 15 more gaps. Each later run did the same, finding the next layer of problems down.
Rules held only when a hook enforced them
For a long time, information discipline was only an instruction. In the end-to-end wargame, a section recommended engaging a target at a location that existed only in the controller's ground-truth file; no friendly sensor had found it. The XO caught it, set the recommendation aside and issued a rule against reading the file. Two other sections had opened it before the rule. The XO noticed that time, but over a longer wargame it wouldn't catch every case. File writes went the same way. Told to write plan files only through the editor tools the recorder watches, the XO in a headless run wrote them with shell commands anyway, and the timeline missed all of it. Both are now hooks that deny the action outright. I now assume any rule that matters needs something besides the model's attention to enforce it.
Citation drift came from my own prompts
Every citation failure across the first two smoke plans was the same thing: a bare paragraph number that picked up the wrong publication from an earlier citation. The skills and agent definitions used the bare form hundreds of times as examples, and one rule in the conventions file lost to all those examples. Qualifying every reference in the prompts by script, and adding a check that holds the prompts to zero bare citations, fixed it.
Sections overran their lanes
An artillery battalion has no engineer section, but the core engineer was convened anyway and wrote products that didn't belong. Ownership of ammunition numbers overlapped between the fire direction officer and the S4, and the XO had to rule on three disputes over the same count. A helper process the XO spawned to send one batch of messages ran ahead and wrote the products for the next two steps. In each case two seats could act in one lane. A pack now has to replace a section instead of adding a second voice in its lane, and ownership has to be split cleanly wherever two sections touch the same number.
The order was weaker than the staff work
A review of the end-to-end products called it a strong staff product and a weak order. The final reconciliation only confirmed what it had been told to check. The order gave three different values for the same enemy timing, an inject's effect never reached two annexes, and 16 locations read "grid to be determined" even though the staff's own overlay had placed every one of them. The decision brief inverted a point from the comparison it summarized. The most heavily weighted evaluation criterion scored a stand-in measure that disagreed with what had actually happened in the wargame. A battalion commander would have sent that order back before signing it.
Cost and time
The end-to-end run made 1,088 model requests, at about $173 in API-equivalent cost: about $50 for the XO and about $117 for the sections. Three things drove most of it. Sections sat idle long enough to lose their cached context and then reloaded all of it, which made up about three-quarters of the cache writes. The XO never shed context, averaging about 489,000 tokens and ending near 871,000. And every section re-read the same files. Time had its own driver. In the wargame the XO spent about two-thirds of the step writing, because it restated each reply three times: to the commander, to the log and in the next turn card. The fixes are in: leaner section instructions, respawning idle sections from their estimates, fixed log blocks, and fewer mid-wargame stops. No full run has measured the savings yet. A short run through the first two steps after the restructure took 18 minutes and about $18.
Graphics only failed on real output
My hand-written sample layers had short labels and a dozen control measures, and the sketches looked fine. The staff wrote around 80 measures per course of action with sentence-length labels, and the sketch was unreadable. Both passed validation. Since then I've judged the renderer only against real runs.
Surprises
The examples beat the rules
I expected the written conventions to govern behavior. They did less than the examples in the prompts. The model writes what the prompts show, so the prompts have to be held to the same checks as the products.
A more honest wargame cost more
The second smoke run took 70 minutes and cost about twice as much as the first. Most of the increase came from making the wargame more honest: a fresh red cell for each course of action, and every turn ending on a friendly response. I think that's the right trade, and it's worth knowing about up front.
The checks only knew what I had taught them
On the end-to-end plan, the health check first reported 5 findings, none high. After I encoded what the mentor-style review had found, the same plan reported 34 findings, 4 of them high. Nothing in the plan had changed.
Replay turned out to be an integrity test
Replaying a run to the end and comparing the result with the files on disk caught things the recorder alone never showed, such as scratch files the XO had created and then deleted with shell commands. Writes that can't be traced now stay visible in the timeline as unattributed.
The XO made claims about the machine without checking
In one run it told the commander the planning board wasn't running when it was. It hadn't checked. That became a rule for every seat: no claim about a file, a check or the board's state without first running the tool call that shows it.
Chat tools need more room than I expected
The chat edition's instructions for one section (persona, SOP and chat rules) run about 20,500 characters, and up to 26,400 for the artillery S3. The SOP core alone is about 9,300. A chat tool that caps instructions near 8,000 characters would push the SOP out into an uploaded document.
A small model couldn't hold the staff together
To see whether this could run fully offline, I ran the first two steps on a small open-weight model, about 20 billion parameters, on local hardware. Speed was fine and quality wasn't. It never convened a single staff section, so the XO wrote stub estimates itself. It got the planning time wrong, restated the higher unit's mission as its own, and accepted both pieces of bad guidance without push-back. A model that small can't run this kind of staff, and any model, large or small, should have to pass the same fixed evaluation before anyone relies on it.
Where human judgment stayed essential
The prototype is built around the commander deciding, and the runs bear that out. Approving the restated mission, choosing evaluation criteria, accepting risk, writing intent and selecting a course of action are where the plan's character comes from. The staff's job was to frame those decisions. In my runs it framed them clearly and argued its case, but deciding whether a criterion measures the right thing, or whether a risk is acceptable, took judgment the staff didn't supply.
Judging whether the order would work took a different kind of read than the checks provide. The end-to-end order passed every automated check and still couldn't have gone out. Its flaws were found by reading it the way a senior planner would. For that run the read was done by separate model sessions told to review as mentors, and I then turned their findings into new checks. That loop needs a person deciding what matters, and the checks will always trail the read.
Some things the staff doesn't see at all. It works from text and a flat notional grid, and in the runs it reasoned about terrain only as distances and labels. I don't trust it on what ground looks like in three dimensions, on what soldiers can sustain, or on how an enemy commander behaves under pressure. Those carry much of a course of action's quality, so I don't treat the staff as an author of courses of action. It drafts, computes, cross-checks and argues, and people own the plan.
Twice the staff disagreed with the commander on solid doctrinal grounds and was overruled. Its job was to make the disagreement plain and then carry out the decision, and it did.
Limits and risks
Fictional data, public doctrine, nothing accredited
Every run used fictional scenarios and notional unit data. The doctrine corpus holds public publications only, and several publications a real staff would use aren't publicly released, so they aren't in it. The prototype isn't accredited for any information or system and isn't in use by any unit. It isn't approved for controlled unclassified or classified information, and it refuses real unit data by default.
Small sample, no baseline
The findings rest on a few runs. I don't yet know whether the staff gives the same answer twice on the same problem, or how its products compare with a trained human staff's on the same scenario. In the end-to-end run the commander was an AI playing a scripted part. A live commander would change the timing and probably the outcome.
The model's blind spots
As described above, the staff doesn't reason well about terrain in three dimensions or about the human side of combat, so it shouldn't author courses of action. The sound way to use it is as a staff that drafts, checks and argues while people do the planning.
Overtrust
Clean symbols, resolved citations and a health panel showing no high findings all look authoritative, and the end-to-end run showed a clean panel over a flawed order. A resolved citation proves that the paragraph exists, not that the argument built on it is sound. A junior officer handed products this tidy may defer to them. Any real use would need the plan's owners to treat the staff's products as drafts from a capable but unproven new staff officer, and to read them that way.
What real use would take
Several things would have to be in place before something like this touched real planning:
- An environment and platform accredited for the data, with a model that environment actually offers. The design keeps the procedure and SOP separate from any one tool so that it can move.
- Data handling that matches the marking. A real unit's readiness and organization data is usually controlled at minimum. The prototype's administrator setting and marking scan keep honest users from loading it by accident. They are not a security control; accreditation of the environment is what guards against misuse.
- A qualification step for each model: a fixed evaluation on fictional scenarios that checks whether citations resolve, required products exist, the enemy player fights, decisions stop at the commander, and specifics aren't invented.
- People in the seats: human seats, observer-controller use, and a commander who reads the products critically.
Open questions and next experiments
- Does the enemy player hold up over a long wargame? The S2 held its role over the turns I've run so far. A full belt-method wargame of 15 or more turns hasn't been tried.
- Does it give the same answer twice? The next evaluation runs the same scenario several times and reports agreement on the recommended course of action, the decision points, the main risks and the restated mission.
- How does it compare with people? The test I most want to run is a human staff and the prototype on the same fictional scenario, graded by the same checks, with experienced planners reading both product sets blind and saying which they would take into a wargame and why.
- Did the cost and tempo fixes work? They're merged and not yet measured on a full seven-step run.
- Does the chat edition work with a human XO? It needs a hands-on run on an approved chat tool, with a person relaying between the seats.
- Which other models qualify? The evaluation suite exists to answer this, and runs on other model families are still ahead.
- Human seats in the agent version, so any seat can be a person with the agent as that officer's assistant.
- Rehearsal and execution: a combined arms rehearsal generated from the synchronization matrix (FM 6-0, appendix C), then an execution mode with a white cell holding ground truth, fragmentary orders, and an after action review that compares what the wargame projected with what happened (FM 6-0, appendix F).
- Nesting, with a brigade staff's warning orders feeding battalion staffs that plan in parallel.
- A shared staff net. Today every message goes through the XO. A shared thread that every section watches, with the XO arbitrating, might be faster. It might also bring back the coordination problems the hub design solved.
References
- FM 5-0, Planning and Orders Production, 4 November 2024 (Change 1). Headquarters, Department of the Army.
- FM 6-0, Commander and Staff Organization and Operations, 16 May 2022. Headquarters, Department of the Army.
- ATP 2-01.3, Intelligence Preparation of the Battlefield, 1 March 2019 (Change 3).
- ATP 5-19, Risk Management, 9 November 2021.
- FM 3-09, Fire Support and Field Artillery Operations, 12 August 2024.
- ATP 3-09.23, Field Artillery Battalion Operations, 25 February 2026.
- FM 3-96, Brigade Combat Team, 19 January 2021.
- MIL-STD-2525D, Joint Military Symbology. Department of Defense.
The doctrine corpus holds 16 publications released to the public (Distribution A) and available from the Army Publishing Directorate at armypubs.army.mil. Paragraph citations in this paper were checked against that corpus as fetched on 6 November 2026.