diff --git a/extensions/openpower-pels/README.md b/extensions/openpower-pels/README.md
index 14fade2..eac30be 100644
--- a/extensions/openpower-pels/README.md
+++ b/extensions/openpower-pels/README.md
@@ -55,4 +55,32 @@
 The PEL message registry is used to create PELs from OpenBMC event logs.
 Documentation can be found [here](registry/README.md).
 
+## `Action Flags` and `Event Type` Rules
+
+The `Action Flags` and `Event Type` PEL fields are optional in the message
+registry, and if not present the code will set them based on certain rules
+layed out in the PEL spec.  In fact, even if they were specified, the checks
+are still done to ensure consistency across all the logs.
+
+These rules are:
+1. Always set the `Report` flag, unless the `Do Not Report` flag is already on.
+2. Always clear the `SP Call Home` flag, as that feature isn't supported.
+3. If the severity is `Non-error Event`:
+    - Clear the `Service Action` flag.
+    - Clear the `Call Home` flag.
+    - If the `Event Type` field is `Not Applicable`, change it to `Information
+      Only`.
+    - If the `Event Type` field is `Information Only` or `Tracing`, set the
+      `Hidden` flag.
+4. If the severity is `Recovered`:
+    - Set the `Hidden` flag.
+    - Clear the `Service Action` flag.
+    - Clear the `Call Home` flag.
+5. For all other severities:
+    - Clear the `Hidden` flag.
+    - Set the `Service Action` flag.
+    - Set the `Call Home` flag.
+
+Additional rules may be added in the future if necessary.
+
 ## D-Bus Interfaces
diff --git a/extensions/openpower-pels/openpower-pels.mk b/extensions/openpower-pels/openpower-pels.mk
index 7690af4..dee798e 100644
--- a/extensions/openpower-pels/openpower-pels.mk
+++ b/extensions/openpower-pels/openpower-pels.mk
@@ -16,6 +16,7 @@
 	extensions/openpower-pels/paths.cpp \
 	extensions/openpower-pels/pce_identity.cpp \
 	extensions/openpower-pels/pel.cpp \
+	extensions/openpower-pels/pel_rules.cpp \
 	extensions/openpower-pels/pel_values.cpp \
 	extensions/openpower-pels/private_header.cpp \
 	extensions/openpower-pels/registry.cpp \
@@ -48,6 +49,7 @@
         extensions/openpower-pels/paths.o \
         extensions/openpower-pels/pce_identity.o \
         extensions/openpower-pels/pel.o \
+        extensions/openpower-pels/pel_rules.o \
         extensions/openpower-pels/pel_values.o \
         extensions/openpower-pels/private_header.o \
         extensions/openpower-pels/registry.o \
diff --git a/extensions/openpower-pels/pel.cpp b/extensions/openpower-pels/pel.cpp
index 1ba5c97..885caed 100644
--- a/extensions/openpower-pels/pel.cpp
+++ b/extensions/openpower-pels/pel.cpp
@@ -19,6 +19,7 @@
 #include "failing_mtms.hpp"
 #include "hexdump.hpp"
 #include "log_id.hpp"
+#include "pel_rules.hpp"
 #include "pel_values.hpp"
 #include "section_factory.hpp"
 #include "src.hpp"
@@ -57,6 +58,8 @@
     }
 
     _ph->setSectionCount(2 + _optionalSections.size());
+
+    checkRulesAndFix();
 }
 
 PEL::PEL(std::vector<uint8_t>& data) : PEL(data, 0)
@@ -160,6 +163,15 @@
     return std::nullopt;
 }
 
+void PEL::checkRulesAndFix()
+{
+    auto [actionFlags, eventType] =
+        pel_rules::check(_uh->actionFlags(), _uh->eventType(), _uh->severity());
+
+    _uh->setActionFlags(actionFlags);
+    _uh->setEventType(eventType);
+}
+
 namespace util
 {
 
diff --git a/extensions/openpower-pels/pel.hpp b/extensions/openpower-pels/pel.hpp
index 3498ae6..4cdbd1d 100644
--- a/extensions/openpower-pels/pel.hpp
+++ b/extensions/openpower-pels/pel.hpp
@@ -240,6 +240,12 @@
     void flatten(std::vector<uint8_t>& pelBuffer);
 
     /**
+     * @brief Check that the PEL fields that need to be in agreement
+     *        with each other are, and fix them up if necessary.
+     */
+    void checkRulesAndFix();
+
+    /**
      * @brief The PEL Private Header section
      */
     std::unique_ptr<PrivateHeader> _ph;
diff --git a/extensions/openpower-pels/pel_rules.cpp b/extensions/openpower-pels/pel_rules.cpp
new file mode 100644
index 0000000..be5e5a2
--- /dev/null
+++ b/extensions/openpower-pels/pel_rules.cpp
@@ -0,0 +1,90 @@
+#include "pel_rules.hpp"
+
+#include "pel_types.hpp"
+
+#include <bitset>
+
+namespace openpower
+{
+namespace pels
+{
+namespace pel_rules
+{
+
+std::tuple<uint16_t, uint8_t> check(uint16_t actionFlags, uint8_t eventType,
+                                    uint8_t severity)
+{
+    std::bitset<16> newActionFlags{actionFlags};
+    uint8_t newEventType = eventType;
+    auto sevType = static_cast<SeverityType>(severity & 0xF0);
+
+    // TODO: This code covers the most common cases.  The final tweaking
+    // will be done with ibm-openbmc/dev#1333.
+
+    // Always report, unless specifically told not to
+    if (!newActionFlags.test(dontReportToHostFlagBit))
+    {
+        newActionFlags.set(reportFlagBit);
+    }
+    else
+    {
+        newActionFlags.reset(reportFlagBit);
+    }
+
+    // Call home by BMC not supported
+    newActionFlags.reset(spCallHomeFlagBit);
+
+    switch (sevType)
+    {
+        case SeverityType::nonError:
+        {
+            // Informational errors never need service actions or call home.
+            newActionFlags.reset(serviceActionFlagBit);
+            newActionFlags.reset(callHomeFlagBit);
+
+            // Ensure event type isn't 'not applicable'
+            if (newEventType == static_cast<uint8_t>(EventType::notApplicable))
+            {
+                newEventType =
+                    static_cast<uint8_t>(EventType::miscInformational);
+            }
+
+            // The misc info and tracing event types are always hidden.
+            // For other event types, it's up to the creator.
+            if ((newEventType ==
+                 static_cast<uint8_t>(EventType::miscInformational)) ||
+                (newEventType == static_cast<uint8_t>(EventType::tracing)))
+            {
+                newActionFlags.set(hiddenFlagBit);
+            }
+            break;
+        }
+        case SeverityType::recovered:
+        {
+            // Recovered errors are hidden, and by definition need no
+            // service action or call home.
+            newActionFlags.set(hiddenFlagBit);
+            newActionFlags.reset(serviceActionFlagBit);
+            newActionFlags.reset(callHomeFlagBit);
+            break;
+        }
+        case SeverityType::predictive:
+        case SeverityType::unrecoverable:
+        case SeverityType::critical:
+        case SeverityType::diagnostic:
+        case SeverityType::symptom:
+        {
+            // Report these others as normal errors.
+            newActionFlags.reset(hiddenFlagBit);
+            newActionFlags.set(serviceActionFlagBit);
+            newActionFlags.set(callHomeFlagBit);
+            break;
+        }
+    }
+
+    return {static_cast<uint16_t>(newActionFlags.to_ulong()), newEventType};
+}
+
+} // namespace pel_rules
+} // namespace pels
+} // namespace openpower
diff --git a/extensions/openpower-pels/pel_rules.hpp b/extensions/openpower-pels/pel_rules.hpp
new file mode 100644
index 0000000..ca05875
--- /dev/null
+++ b/extensions/openpower-pels/pel_rules.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <cstdint>
+#include <tuple>
+
+namespace openpower
+{
+namespace pels
+{
+namespace pel_rules
+{
+
+/**
+ * @brief Ensure certain PEL fields are in agreement, and fix them if they
+ *        aren't.  These rules are documented in the README.md in this
+ *        directory.
+ *
+ * Note: The message registry schema enforces that there are no undefined
+ *       bits set in these fields.
+ *
+ * @param[in] actionFlags - The current Action Flags value
+ * @param[in] eventType - The current Event Type value
+ * @param[in] severity - The current Severity value
+ *
+ * @return std::tuple<actionFlags, eventType> - The corrected values.
+ */
+std::tuple<uint16_t, uint8_t> check(uint16_t actionFlags, uint8_t eventType,
+                                    uint8_t severity);
+
+} // namespace pel_rules
+} // namespace pels
+} // namespace openpower
diff --git a/extensions/openpower-pels/pel_types.hpp b/extensions/openpower-pels/pel_types.hpp
index d19c875..ae886eb 100644
--- a/extensions/openpower-pels/pel_types.hpp
+++ b/extensions/openpower-pels/pel_types.hpp
@@ -79,7 +79,9 @@
  */
 enum class EventType
 {
-    notApplicable = 0x00
+    notApplicable = 0x00,
+    miscInformational = 0x01,
+    tracing = 0x02
 };
 
 /**
@@ -97,5 +99,25 @@
     symptom = 0x70
 };
 
+/**
+ * @brief The Action Flags values with the bit
+ *        numbering needed by std::bitset.
+ *
+ * Not an enum class so that casting isn't needed
+ * by the bitset operations.
+ */
+enum ActionFlagsBits
+{
+    serviceActionFlagBit = 15,       // 0x8000
+    hiddenFlagBit = 14,              // 0x4000
+    reportFlagBit = 13,              // 0x2000
+    dontReportToHostFlagBit = 12,    // 0x1000
+    callHomeFlagBit = 11,            // 0x0800
+    isolationIncompleteFlagBit = 10, // 0x0400
+    spCallHomeFlagBit = 8,           // 0x0100
+    osSWErrorBit = 7,                // 0x0080
+    osHWErrorBit = 6                 // 0x0040
+};
+
 } // namespace pels
 } // namespace openpower
diff --git a/extensions/openpower-pels/user_header.cpp b/extensions/openpower-pels/user_header.cpp
index 432ae67..8092e38 100644
--- a/extensions/openpower-pels/user_header.cpp
+++ b/extensions/openpower-pels/user_header.cpp
@@ -62,8 +62,20 @@
 
     // TODO: ibm-dev/dev/#1144 Handle manufacturing sev & action flags
 
-    _eventType = entry.eventType.value_or(
-        static_cast<uint8_t>(EventType::notApplicable));
+    if (entry.eventType)
+    {
+        _eventType = *entry.eventType;
+    }
+    else
+    {
+        // There are different default event types for info errors
+        // vs non info ones.
+        auto sevType = static_cast<SeverityType>(_eventSeverity & 0xF0);
+
+        _eventType = (sevType == SeverityType::nonError)
+                         ? static_cast<uint8_t>(EventType::miscInformational)
+                         : static_cast<uint8_t>(EventType::notApplicable);
+    }
 
     _reserved4Byte1 = 0;
 
@@ -71,6 +83,7 @@
     _problemDomain = 0;
     _problemVector = 0;
 
+    // These will be cleaned up later in pel_rules::check()
     _actionFlags = entry.actionFlags.value_or(0);
 
     _reserved4Byte2 = 0;
diff --git a/extensions/openpower-pels/user_header.hpp b/extensions/openpower-pels/user_header.hpp
index 459952b..b382a84 100644
--- a/extensions/openpower-pels/user_header.hpp
+++ b/extensions/openpower-pels/user_header.hpp
@@ -102,6 +102,16 @@
     }
 
     /**
+     * @brief Set the event type field
+     *
+     * @param[in] type - the new event type
+     */
+    void setEventType(uint8_t type)
+    {
+        _eventType = type;
+    }
+
+    /**
      * @brief Returns the problem domain field.
      *
      * @return uint8_t - the problem domain
@@ -132,6 +142,16 @@
     }
 
     /**
+     * @brief Sets the action flags field
+     *
+     * @param[in] flags - the new action flags
+     */
+    void setActionFlags(uint16_t flags)
+    {
+        _actionFlags = flags;
+    }
+
+    /**
      * @brief Returns the size of this section when flattened into a PEL
      *
      * @return size_t - the size of the section