Portrait of Keya Moradi
← Back to writing

MissionThread AI: An Auditable Copilot for Complex Programs

MissionThread AIAI Program ManagementAgentic AIAI GovernanceAuditable AIHuman in the Loop

Most AI demos begin with a chat box. MissionThread AI begins with a supplier delay.

That matters because complex programs rarely break in one neat place. A supplier slips by 28 days. That affects a component. The component supports requirements. Those requirements connect to tests, defects, milestones, risks, and budget. By the time everyone assembles the full picture, the decision has already aged.

I built MissionThread AI to make that chain visible and actionable. It is an auditable AI program management platform for complex hardware and software delivery. It connects the moving parts of a program, calculates what changed, asks AI to interpret the evidence, and keeps the final authority with a human.

Short version: it gives a complex program a memory, a map, and a brake pedal.

What MissionThread AI Actually Does

MissionThread creates a digital thread across:

  • Components and requirements
  • Milestones and dependencies
  • Risks and budgets
  • Tests and defects
  • Suppliers and program events
  • AI analyses, mitigation options, decisions, and applied changes

The phrase digital thread is not just branding. NIST’s Digital Thread for Manufacturing work focuses on connecting product information across the lifecycle so teams can respond to changing conditions without losing context. MissionThread applies that same idea to program control and decision making.

When a Program Manager records a supplier delay or general update, MissionThread can trace the affected records, calculate schedule and budget exposure, identify verification gaps, score risk, and capture the program’s readiness at that moment.

It then shows the program as a searchable graph. A user can move from a supplier event to the affected component, requirements, tests, risks, milestones, analysis, decision, and applied change. Evidence citations become visible relationships instead of footnotes buried in a slide deck.

The AI Has a Job Description, Not the Keys

This is the most important design choice in the project: the math and the AI do different jobs.

Deterministic code calculates dates, dollars, dependency chains, risk scores, verification gaps, and readiness. The model does not get to guess those values. The AI layer receives a bounded projection of that evidence and does what language models are good at: explaining the impact and proposing options.

Every successful analysis must produce exactly three mitigation options, with exactly one marked as recommended. Every cited record ID must exist in the evidence supplied to that specific attempt. If the model invents an ID, changes a deterministic amount, returns malformed output, or exceeds a defined boundary, the response is rejected.

The protected workflow is simple:

event
  → deterministic impact analysis
  → bounded AI interpretation
  → three mitigation options
  → human decision
  → apply preview
  → transactional apply
  → audit trail

The model cannot approve its own recommendation. It cannot apply a change. It cannot quietly rewrite a milestone or budget item.

A Program Manager reviews the options, records a decision, sees the old and proposed values, and must type the exact word APPLY before an approved change can be committed. MissionThread checks for stale data again at apply time. If one proposed change is invalid or outdated, the entire batch stops. No partial mutation. No mystery state.

An Engineering Lead can request revision. An Executive Viewer remains read-only. Every real mutation rechecks the user’s current role in the database instead of trusting a potentially stale session claim.

Why This Is Relevant in the Agentic AI Era

We have already moved beyond the phase where AI only answers questions. ChatGPT, Claude, Gemini, coding agents, and enterprise copilots are training people to expect AI to use tools and complete work.

OpenAI describes the Responses API as a foundation for agentic applications, while the Model Context Protocol is standardizing how AI systems connect to external data and tools. That makes a new question unavoidable:

Once AI can act, how do we prove what it saw, limit what it can do, and reconstruct what happened?

MissionThread is my answer to that question in a program management setting.

I have written before about control layers for AI systems and guardrails for coding assistants. This project is the same instinct applied to a full working system.

It includes a local MCP server with exactly six bounded, read-only tools for program summary, requirements, schedule dependencies, failed tests, budget variance, and risk register queries. An MCP client can ask useful questions about the same program data without receiving a write path.

That is the practical side of AI governance. It is not a policy document sitting in a folder. It is capability boundaries, strict schemas, evidence allowlists, role checks, approval gates, rate limits, and audit records built into the workflow itself. That lines up with the broader direction of the NIST AI Risk Management Framework, which emphasizes defined roles, oversight, measurement, and active risk management.

Built to Fail Loudly

The repository is intentionally a little paranoid. I consider that a compliment.

  • Mock AI is the default for development and CI, so the full pipeline works without an API key or network call.
  • Live mode uses the OpenAI Responses API with structured output, a fixed timeout, an output token ceiling, and no hidden SDK retries.
  • Provider output is size-checked, structurally validated, semantically validated, and rejected if it disagrees with deterministic facts.
  • Supplier notes are isolated as untrusted data and never mixed into trusted program facts.
  • Analysis requests are rate limited before provider work begins.
  • At the reviewed v1.0.1 state, the documented test suite includes 837 workspace tests plus 17 separate root audit-gate regression tests.
  • CI covers linting, formatting, types, database migrations, tests, mock evaluations, production build, browser testing, Docker build, a live container smoke test, and a blocking dependency advisory gate.
  • The threat model covers prompt injection, broken authorization, unauthorized mutation, hallucinated facts, stale approvals, denial of wallet, logging exposure, and MCP boundaries.

The live provider evaluation also passed six out of six fixed scenarios, including an adversarial prompt injection fixture. That is useful evidence for one model, one date, and six inputs. It is not proof that a live model is universally reliable, and the repository says so plainly.

What It Is Not

MissionThread is a serious MVP, but it is still an MVP.

  • It is not deployed production software with public signup, cloud infrastructure, queues, or horizontal scaling.
  • Its analysis rate limiter is local to one process.
  • Its MCP server is read-only at the application layer, but it does not yet use a dedicated read-only database credential.
  • Its audit history is append only through the application, not cryptographically immutable against a database administrator.
  • All program, supplier, and personnel data in the repository is fictional, synthetic, and unclassified.

I would rather state those boundaries clearly than turn a good prototype into a fake enterprise case study.

Why I Think It Matters

Most AI products optimize for a better answer. MissionThread is designed around a better decision:

  • The evidence is visible.
  • The math is reproducible.
  • The model’s authority is limited.
  • The human decision is explicit.
  • The change is previewed.
  • The history can be reconstructed.

That pattern is useful far beyond one demo program. Aerospace, defense, manufacturing, infrastructure, supply chains, and other complex delivery environments all live with the same basic problem: one change can ripple across systems faster than a team can manually trace it.

The near term win for AI is not replacing the Program Manager. It is compressing the time between signal and defensible decision without hiding uncertainty or handing the keys to the model.

That is less cinematic than an autonomous agent running the company. It is also much closer to something a serious organization could trust.

Explore the code, architecture, threat model, screenshots, and demo workflow at github.com/Keya-Moradi/Mission-Thread-AI.

Tags: #MissionThreadAI #AIProgramManagement #AgenticAI #AIGovernance #AuditableAI #HumanInTheLoop #DigitalThread #ModelContextProtocol #MCP #TechnicalProgramManagement #SystemsEngineering #EnterpriseAI #ResponsibleAI #AIDecisionSupport #SupplyChainRisk