DecisionReady

• 

  New Governed Baseline — shows the approved change becoming the new baseline.

• 

  Readiness Transition — shows the movement from NOT_READY toward governed readiness.

• 

  Audit Trail — proves DecisionReady preserves the governed decision history.

• 

  DecisionReady Architecture — shows the trust boundary: deterministic engine + Strands/Nova + human authority.

Inspiration

Most AI assistants are designed to answer questions, summarize information, or recommend what someone should do. But in complex programs, the harder problem is often not generating an answer — it is determining whether an organization has enough governed evidence to make a consequential decision at all.

That became the inspiration for DecisionReady.

Program managers, technical program managers, governance teams, and executives regularly face decisions involving scope, schedules, privacy, compliance, resources, architecture, vendors, and risk. Information may exist across different teams, but there is often no clear system that distinguishes:

• what changed,
• what is impacted,
• what evidence is required,
• what approvals are still missing,
• whether the decision is actually ready,
• and who is authorized to make the final decision.

DecisionReady was built around one principle:

AI explains. Deterministic controls establish readiness. Humans decide.

The goal was not to build another AI assistant. It was to build a governed decision system.

What it does

DecisionReady turns a proposed project change into a structured, auditable decision-readiness process.

A business user can upload a familiar Excel workbook containing:

• the current approved project baseline,
• the proposed change,
• and the proposed future state.

DecisionReady then:

1. Compares the proposed state against the approved baseline.
2. Detects the authoritative changes.
3. Traces the resulting blast radius across domains such as privacy, resources, schedule, and scope.
4. Derives required evidence and approvals from deterministic governance rules.
5. Calculates a readiness state such as NOT_READY, READY, or BLOCKED.
6. Uses a Strands Agent with Amazon Nova 2 Lite to explain the authoritative analysis and recommended next actions.
7. Requires humans to provide evidence sources and named approvers.
8. Keeps final approval locked until the deterministic readiness conditions are satisfied.
9. Preserves the final consequential decision for an authorized human.
10. Promotes an approved change into a new governed baseline and records the audit history.

A critical distinction is that:

READY does not mean APPROVED.

READY only means that the governance conditions required to make the decision have been satisfied. The final decision remains human.

In our Germany launch scenario, DecisionReady detects four project changes, identifies four impact domains, requires two evidence items and two approvals, moves from NOT_READY to READY only when those conditions are satisfied, and then allows an authorized human governance body to approve the change and promote baseline v1 to v2.

How we built it

DecisionReady combines deterministic governance logic with agentic AI.

The application is written in Python and uses a deterministic decision engine for authoritative controls including:

• baseline comparison,
• change detection,
• impact analysis,
• governance requirement derivation,
• evidence validation,
• approval validation,
• blocker management,
• readiness evaluation,
• human decision enforcement,
• baseline promotion,
• and audit-history generation.

For the AI layer, we used:

• Strands Agents
• Amazon Bedrock
• Amazon Nova 2 Lite

The Strands Agent does not independently decide whether a project is ready. Instead, it calls the authoritative DecisionReady analysis and explains the result in business-friendly language.

This separation is intentional.

The deterministic engine owns facts and governance states. The AI layer owns explanation and reasoning around those authoritative results. The human owns the consequential decision.

For the user experience, we built a Streamlit workspace where users can upload an Excel workbook, review detected changes and governance requirements, generate an AI decision brief, enter evidence and approvals, and record the final human decision.

The live application is deployed on AWS Elastic Beanstalk, and the project includes automated tests covering the core lifecycle.

Challenges we ran into

One of the biggest challenges was defining the trust boundary between AI reasoning and authoritative governance.

For example, during development, a model once described a launch date moving from October 1 to October 15 as an acceleration. That exposed an important design lesson: facts that can be deterministically derived should not depend on probabilistic language-model interpretation.

We changed the architecture so that temporal direction and other derivable facts are computed deterministically before the AI explains them.

Another challenge was preventing the system from confusing readiness with approval. Many AI systems naturally tend to move toward recommendations or conclusions. DecisionReady instead had to enforce a strict separation:

• evidence may be satisfied,
• approvals may be obtained,
• readiness may become READY,
• but only an authorized human can APPROVE, REJECT, or DEFER.

We also had to translate governance concepts into a workflow simple enough for business users. That led us to support Excel-based project submission instead of requiring JSON or developer-oriented input.

Deployment and production readiness also required work around AWS permissions, Bedrock invocation, Streamlit hosting, dependency management, and public application deployment.

Finally, UX testing revealed how important clear transitions are. After analysis, users need to immediately understand where the authoritative result begins and what action comes next. We refined the interface around that workflow.

Accomplishments that we're proud of

We are especially proud that DecisionReady demonstrates an end-to-end governed decision lifecycle rather than only producing an AI-generated recommendation.

The working system can demonstrate:

Approved Baseline → Proposed Change → Change Detection → Impact Analysis → Governance Requirements → NOT_READY → READY → Human Decision → New Baseline → Audit History

We are also proud that the AI is deliberately not the final authority.

The product enforces several governance principles directly in the application:

• evidence only counts when a source is provided,
• approval only counts when a named approver is provided,
• explicit blockers prevent readiness,
• APPROVE is unavailable until readiness is READY,
• READY is explicitly separated from APPROVED,
• only a READY + human APPROVED decision creates a new baseline.

Our live Germany scenario successfully demonstrates:

• 4 detected changes,
• 4 impact domains,
• 2 required evidence items,
• 2 required approvals,
• deterministic transition from NOT_READY to READY,
• authorized human approval,
• baseline promotion from v1 to v2,
• and an exportable governed decision record.

The project also has 46 passing automated tests, a public live application, a documented architecture, project evidence, and a reproducible demo scenario.

What we learned

The biggest lesson was that trustworthy enterprise AI is not only about making models more intelligent.

It is about deciding which parts of the system should not be probabilistic at all.

AI is excellent at explaining complex context, synthesizing information, and helping humans understand consequences. But governance states, required controls, baseline versions, blockers, evidence status, and authorization boundaries benefit from deterministic enforcement.

We also learned that human-in-the-loop design is much stronger when the human is not simply confirming an AI recommendation.

In DecisionReady, the human is the actual authority.

The agent helps create understanding. The controls establish whether the decision is ready. The human makes the decision.

That architectural separation became the core of the project.

What's next for DecisionReady

The next step is to evolve DecisionReady from a hackathon prototype into an enterprise decision-governance platform.

Future capabilities could include:

• integrations with Jira, ServiceNow, Slack, Microsoft Teams, Google Workspace, and enterprise PM systems,
• automated evidence collection from approved enterprise systems,
• configurable governance policies by organization or industry,
• role-based authorization and identity verification,
• cryptographically verifiable audit histories,
• portfolio-level decision readiness dashboards,
• cross-project dependency analysis,
• policy and regulatory rule libraries,
• executive decision queues,
• decision SLA tracking,
• change-risk scoring,
• and organizational learning from historical decisions and outcomes.

We also see DecisionReady becoming a control layer between enterprise AI agents and consequential business actions.

The long-term vision is simple:

Before an AI-enabled organization acts, DecisionReady should be able to answer: Is this decision actually ready to be made?

Built With

• agentic-ai
• ai-agents
• ai-governance
• amazon-bedrock
• amazon-nova
• amazon-web-services
• audit-trail
• change-management
• compliance
• decision-intelligence
• decision-support
• elasticbeanstalk
• enterprise-ai
• excel
• explainable-ai
• governance
• human-in-the-loop
• nova-2-lite
• program-management
• project-management
• python
• responsible-ai
• risk-management
• strands-agents
• streamlit