For decades the Combat Air Forces have held Weapons and Tactics conferences — WepTacs — at Nellis to turn hard lessons into doctrine: how to employ a bomb, beat a radar, fly a plan. Tasking, injects, red teams, vignettes. It is how a generation of airmen learned to take the fight to the next level.
Our weapons are software now. Every patch, every model update, every container we deploy is a doctrinal change — and we have no range to fight-test any of it, much less a respected group of tactical practitioners to red-team it left of bang. What we have instead are "innovation weeks": a demo for a general, a round of applause, and nothing that ever ships.
BLUF: The answer is a Software WepTac — not a conference, an operational exercise. Run quarterly on the civilian tech calendar, chaired by U.S. Cyber Command (CYBERCOM), with the discipline of a Nellis WepTac, it puts Pathfinders, the service software factories, and operational units in one room to ship live code against real kill-chain threads. They leave with artifacts that change both the interface and the money. That is the observe-orient-decide-act (OODA) loop, run in code, as an institution.
Why innovation weeks die
Every "innovation week" I've watched died on the same runway, and for the same reason: its outputs never changed an interface or a dollar. People flew in, whiteboarded, demoed something impressive, and flew home. The demo moved some minds for an afternoon. Then the fiscal-year machine kept turning, nothing was funded, no system changed what it published or subscribed to, and six months later the "winner" was a slide in an old deck.
The WepTac model is the opposite by design, because its entire output is runtime evidence and contracting templates, not talking points. You don't come to be inspired. You come with deployable code and leave having changed the plumbing everyone else has to build to.
Two things kill these events, and the WepTac is built to defeat both. The first is heroics: the week works because a handful of talented people will it into being, and when they rotate out, it dies — which is why the people who run the cells have to be a standing career path, not volunteers on loan. The second is weightlessness: the outputs touch nothing that lasts. A briefing is not an interface. Applause is not a funding lane. The WepTac forces every cell to produce something that changes the plumbing or the money, and then names a team to go install it — because the artifact nobody owns is the artifact that never ships.
A demo changes minds for an afternoon. An interface order changes the plumbing for everyone, permanently.
What the exercise actually is
Hold it quarterly, in cadence with the tech world's own rhythm — Black Hat, DEFCON, RSA, the Armed Forces Communications and Electronics Association (AFCEA) events, the Department's artificial-intelligence symposia — so the force is learning on the same clock as the industry it's trying to keep pace with. Put the right people on target: Pathfinders, the Defense Innovation Unit (DIU), the Super Intelligence Office (SIO), the service software factories (Kessel Run, Platform One, BESPIN, Space Camp, Kobayashi Maru, and the Army, Navy, and Marine shops), their contractor performers, and the operational units who actually own the problem.
The Nellis discipline is the point, not the decoration. A WepTac ride is graded, not workshopped. Red teams play a real, current adversary. Vignettes are real mission problems, not hypotheticals. Injects arrive uncomfortably and mid-exercise, exactly as they would in combat — a dependency changes, a cloud region drops, a fresh vulnerability lands in a shared library — and the cell has to adapt inside a clock. You pass, or you learn in front of your peers, on the evidence, why you didn't. Importing that culture to software is how you build operators who can fight code under pressure instead of engineers who can demo it in a quiet room.
Aim the whole thing at the muscles the Pentagon keeps skipping: interfaces, data contracts, continuous authorization to operate (cATO) inheritance, service-level objectives (SLOs), and contracting lanes. The deliverables fall into a handful of categories, and every one of them is something you can execute, not file:
- Application programming interface (API) fragmentary orders (FRAGOs) for two or three joint kill-chain threads — think sensor-to-shooter, or mobility-to-fuel-to-command — with versioned schemas, error budgets, and decision-authority timing. These are the same data contracts a joint force fights on, written down and owned like any other order.
- Data service-level agreements (SLAs), owned by SIO — latency, completeness, accuracy — with test vectors you can run across cloud, edge, and coalition enclaves.
- cATO-by-design playbooks: inheritance packages and pipeline-attested controls a vendor or factory can reuse once, everywhere, instead of re-papering security for every program.
- Contracting ordering guides that template the rapid buy of what just got proven — budget program activity codes (BPACs), Small Business Innovation Research (SBIR) Phase III task orders, other-transaction agreements (OTAs).
- Manning and rotation plans for the Pathfinder billets that have to carry the work home.
The five-day loop
Run it as one turn of an OODA loop, then repeat it next quarter. Vignettes, injects, and target metrics go out two weeks prior, and everyone shows up with deployable code and adapters — no mock-ups by lunch. Day 1 (observe and orient): red teams brief the current exploited-vulnerability picture and opposing-force injects; SIO posts the target metrics; DIU releases the inheritance pack. Day 2 (decide): Pathfinder cells run interface spikes, capture what breaks, and draft the API FRAGOs, while contracting cells map which lanes can fund a fix in real time. Day 3 (act): teams ship live patches to the development fabric with cATO evidence emitted automatically by the pipeline, and the dashboards write themselves. Day 4 (debrief and publish): out come three tangible things — updated interface orders and data agreements, a contracting ordering guide, and the manning requests to sustain it. Day 5 and beyond: a named Tiger Team stays on target for two weeks back at home station to push those artifacts into actual programs — contract modifications, SBIR pivots, acquisition memos. If nothing gets named, nothing happened.
No artifacts, it didn't happen. The exercise is graded in shipped code and signed contract language, not applause.
Make it concrete. Take a sensor-to-shooter thread: intelligence, surveillance, and reconnaissance (ISR) data that has to reach a shooter inside a decision window. Day 1, the red team shows how today's bespoke integration shatters the moment one feed changes format mid-mission. By Day 2 a Pathfinder cell has drafted an API FRAGO that pins the schema, the error budget, and who is allowed to decide what, by when. Day 3, two different vendors' systems publish and subscribe to that contract live on the development fabric, security evidence emitted automatically by the pipeline. Day 4, the thread's data agreement and ordering guide are signed; Day 5, a Tiger Team carries them into the program office that owns the kill chain. What used to be a year of custom handshakes ending in a slide becomes a week of shipped code and a contract vehicle anyone can order against.
Why this one sticks
Past innovation efforts were person-bound — they worked because a few heroes willed them to — and perishable the moment those people left. The Software WepTac is interface-bound instead. Every successful turn produces a new API FRAGO, a new funding lane, and an auditable record of how fast the force can actually change. It turns CYBERCOM, DIU, SIO, and the service factories into a single software maneuver force with OODA discipline and budget agility. Its sibling — a matching exercise that aligns the acquisition front doors, rights, and money to the same rhythm — is the subject of a later post. This one is about the code.
The deeper reason it works is that it refuses to optimize for the wrong thing. When an innovation pipeline narrows to pitch theater, you get outputs without outcomes — activity, decks, enthusiasm, and nothing different in the field. When it is yoked to joint interfaces, the service factories, and production targets, you get effects. And because every artifact is versioned and every patch carries its own evidence, the exercise produces something the Department has never been able to generate on demand: an honest, auditable measure of how fast it can actually change — time to field (T2F) a capability, time to a decision (T2D), time to patch (T2P) a known-exploited vulnerability (KEV) — trended quarter over quarter. Right now we measure modernization in dollars obligated, which says nothing about whether the force got faster or better. This measures the only thing that matters.
The fix
Stand up the Software WepTac as a real, quarterly, CYBERCOM-chaired exercise with Nellis discipline: published vignettes, deployable-code entry standard, red-team injects, and a Tiger Team that wires the outputs into programs within two weeks. Grade it the way Nellis grades a proposed tip-to-test — on what actually works — and measure the force by the interface orders it publishes and the threads that meet their targets, not by the number of innovation events it holds. The pieces already exist: the data contracts, the continuous-authorization pipeline, the Pathfinders to run the cells. What's missing is the range to fight them on.
What you can do Monday
- Unit commanders: When the first one runs, send an operational team with a real problem and working code, not an observer with a notebook. The units that show up with something deployable are the ones who leave with their interface fixed.
- PEOs / PAEs: Accept the exercise's API FRAGOs and ordering guides as the standard your programs build to. Fund outputs that shipped, not demos that didn't.
- Contracting officers: Staff the contracting cell and bring your lanes — the BPACs, the SBIR Phase III vehicles, the OTAs — so a fix proven Tuesday has money on it by Thursday.
- CYBERCOM and the service software factories: Co-run it. Bring the cATO inheritance pack and the factory performers, and hold the line that the entry fee is deployable code.
- OSD (SIO and the DoW CIO): Own the data agreements and the schema registry the exercise feeds, and publish them in a repository the whole joint force can read.
- Congress: No new authority needed. Ask for software progress reported as interface orders published and threads meeting their targets, with change velocity trending, not as dollars spent or events held.
The conversation happens on LinkedIn — come argue with me there.