diff --git a/.cardano-dev.yaml b/.cardano-dev.yaml
deleted file mode 100644
index e39231c182..0000000000
--- a/.cardano-dev.yaml
+++ /dev/null
@@ -1,22 +0,0 @@
-version: 2
-main-branch: main
-release-branch:
-  prefix: release/
-  suffix: .x
-changelog:
-  # Determine which PR changelog options are available and which end up in the changelog
-  options:
-    type:
-      feature: add
-      breaking: add
-      compatible: add
-      optimisation: add
-      bugfix: add
-      refactoring: skip
-      test: skip
-      maintenance: skip
-      release: skip
-      documentation: skip
-
-      # deprecated, left here only for backwards compatible changelog generation
-      improvement: add
diff --git a/.changes/20260327_185614_cardano-rpc_mateusz.galazyn.yml b/.changes/20260327_185614_cardano-rpc_mateusz.galazyn.yml
new file mode 100644
index 0000000000..9590d7d3c8
--- /dev/null
+++ b/.changes/20260327_185614_cardano-rpc_mateusz.galazyn.yml
@@ -0,0 +1,5 @@
+description: unimportant refactoring
+kind:
+- refactoring
+pr: 1234
+project: cardano-rpc
diff --git a/.changes/20260327_185614_cardano-wasm_mateusz.galazyn.yml b/.changes/20260327_185614_cardano-wasm_mateusz.galazyn.yml
new file mode 100644
index 0000000000..ea3811b3fe
--- /dev/null
+++ b/.changes/20260327_185614_cardano-wasm_mateusz.galazyn.yml
@@ -0,0 +1,5 @@
+description: unimportant refactoring
+kind:
+- refactoring
+pr: 1234
+project: cardano-wasm
diff --git a/.changes/20260327_185802_cardano-rpc_mateusz.galazyn.yml b/.changes/20260327_185802_cardano-rpc_mateusz.galazyn.yml
new file mode 100644
index 0000000000..5668bd0baa
--- /dev/null
+++ b/.changes/20260327_185802_cardano-rpc_mateusz.galazyn.yml
@@ -0,0 +1,6 @@
+description: Fixed some bug
+kind:
+- bugfix
+- compatible
+pr: 1235
+project: cardano-rpc
diff --git a/.changes/_TEMPLATE.yml b/.changes/_TEMPLATE.yml
new file mode 100644
index 0000000000..7760f13bd0
--- /dev/null
+++ b/.changes/_TEMPLATE.yml
@@ -0,0 +1,16 @@
+# Changelog fragment template - copy this file and fill in the fields.
+# Or use 'herald new' for interactive creation.
+#
+# Files starting with _ are ignored by herald.
+#
+# Available projects and kinds are defined in .herald.yml
+
+# Which project this change belongs to (see 'projects' in .herald.yml)
+project: my-project
+# Pull request number associated with this change
+pr: 0
+# One or more change kinds (see 'kinds' in .herald.yml)
+kind:
+  - bugfix
+description: |
+  Describe your change here.
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index a9c5713a73..86afb55121 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,28 +1,22 @@
 # Changelog
 
-```yaml
-- description: |
-    <insert-changelog-description-here>
-# uncomment types applicable to the change:
-  type:
-  # - feature        # introduces a new feature
-  # - breaking       # the API has changed in a breaking way
-  # - compatible     # the API has changed but is non-breaking
-  # - optimisation   # measurable performance improvements
-  # - refactoring    # QoL changes
-  # - bugfix         # fixes a defect
-  # - test           # fixes/modifies tests
-  # - maintenance    # not directly related to the code
-  # - release        # related to a new release preparation
-  # - documentation  # change in code docs, haddocks...
-# uncomment at least one main project this PR is associated with
-  projects:
-  # - cardano-api
-  # - cardano-api-gen
-  # - cardano-rpc
-  # - cardano-wasm
+Every PR needs a changelog fragment in `.changes/`. Create one with:
+
+```bash
+herald new
+```
+
+Or non-interactively:
+
+```bash
+herald new -p cardano-api -k bugfix -d "Fix something" --pr 1234
 ```
 
+Available projects: `cardano-api`, `cardano-api-gen`, `cardano-rpc`, `cardano-wasm`
+Available kinds: `breaking`, `feature`, `compatible`, `bugfix`, `optimisation`, `refactoring`, `test`, `maintenance`, `release`, `documentation`
+
+See `.herald.yml` for full configuration. CI will validate your fragment automatically.
+
 # Context
 
 Additional context for the PR goes here. If the PR fixes a particular issue please provide a [link](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword=) to the issue.
@@ -36,6 +30,7 @@ Highlight important bits of the PR that will make the review faster. If there ar
 - [ ] Commit sequence broadly makes sense and commits have useful messages
 - [ ] New tests are added if needed and existing tests are updated. See [Running tests](https://github.com/input-output-hk/cardano-node-wiki/wiki/Running-tests) for more details
 - [ ] Self-reviewed the diff
+- [ ] Changelog fragment added in `.changes/`
 
 <!--
 ### Note on CI ###
diff --git a/.github/workflows/check-pr-changelog.yml b/.github/workflows/check-pr-changelog.yml
index a11ae08fdb..c88b50d65a 100644
--- a/.github/workflows/check-pr-changelog.yml
+++ b/.github/workflows/check-pr-changelog.yml
@@ -1,101 +1,26 @@
-name: Check if PR changelog was filled correctly
+name: Check changelog fragments
+
 on:
   merge_group:
   pull_request:
-    types: [opened, edited, synchronize, ready_for_review]
+    types: [opened, synchronize, ready_for_review]
 
 jobs:
   check-changelog:
+    if: ${{ github.event_name != 'merge_group' }}
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        if: ${{ github.event_name != 'merge_group' }}
         with:
-          node-version: 22
+          fetch-depth: 0
 
-      - run: npm install js-yaml@4.1.0
-        if: ${{ github.event_name != 'merge_group' }}
-
-      - name: Fail if PR changelog is not correct
-        if: ${{ github.event_name != 'merge_group' }}
-        uses: actions/github-script@v8
-        id: check-changelog
+      - uses: cachix/install-nix-action@v30
         with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const yaml = require('js-yaml');
-            const fs   = require('fs');
-            const execSync = require('child_process').execSync;
-
-            const prDescription = await github.rest.pulls.get({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              pull_number: context.issue.number
-            });
-
-            const changelogRegex = /# Changelog[\s\S]*?```yaml([\s\S]*?)```/;
-            const changelogMatch = prDescription.data.body.match(changelogRegex);
-            const yamlContent = changelogMatch ? changelogMatch[1].trim() : '';
-            yamlContent || console.error('Failed to find changelog YAML section in the "Changelog" paragraph');
-
-            try {
-              changelog = yaml.load(yamlContent)[0];
-            } catch (e) {
-              console.error('Failed to parse YAML changelog as array:', yamlContent);
-              process.exit(1);
-            }
-
-            try {
-              config = yaml.load(fs.readFileSync('.cardano-dev.yaml', 'utf8'));
-            } catch (e) {
-              console.error('Failed to load .cardano-dev.yaml config:', e);
-              process.exit(1);
-            }
-
-            let isCompatibilityValid = false;
-            if (!changelog.compatibility) {
-              isCompatibilityValid = true;
-            }
-            if (!isCompatibilityValid) {
-              console.error('Changelog field "compatibility" is deprecated and no longer used. Please remove it.');
-            }
-
-            let isTypeValid = false;
-            const validTypeValues = Object.keys(config.changelog.options.type);
-            if (Array.isArray(changelog.type) && !!changelog.type) {
-              isTypeValid = changelog.type.every(value => validTypeValues.includes(value));
-            } else {
-              isTypeValid = validTypeValues.includes(changelog.type);
-            }
-            if (!isTypeValid) {
-              console.error(`PR changelog has invalid type: ${changelog.type}\nExpected one, or more of: ${validTypeValues}`)
-            }
-
-            let isProjectsValid = false;
-            // .filter(Boolean) is a trick that removes empty values from the array (see https://michaeluloth.com/javascript-filter-boolean/)
-            const validProjectsValues = execSync("ls */CHANGELOG* | cut -d/ -f1").toString().split('\n').filter(Boolean)
-            if (Array.isArray(changelog.projects) && !!changelog.projects) {
-              isProjectsValid = changelog.projects.every(value => validProjectsValues.includes(value));
-            } else {
-              isProjectsValid = validProjectsValue.includes(changelog.projects);
-            }
-            if (!isProjectsValid) {
-              console.error(`PR changelog has invalid project: ${changelog.projects}\nExpected one, or more of: ${validProjectsValues}`)
-            }
-
-            let isDescriptionValid = true;
-            if (changelog.description.trim() === '<insert-changelog-description-here>') {
-              console.error('PR changelog description has not been updated!')
-              isDescriptionValid = false;
-            } else if (!changelog.description.trim()) {
-              console.error('PR changelog description field is missing!')
-              isDescriptionValid = false;
-            }
-
-            if (!isCompatibilityValid || !isTypeValid || !isProjectsValid || !isDescriptionValid) {
-              console.error('Failed PR changelog checks!');
-              process.exit(1);
-            }
+          nix_path: nixpkgs=channel:nixos-unstable
+          extra_nix_config: |
+            trusted-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ=
+            substituters = https://cache.iog.io/ https://cache.nixos.org/
 
+      - uses: input-output-hk/cardano-dev/herald/.github/actions/validate@mgalazyn/release-tool
+        with:
+          version: github:input-output-hk/cardano-dev/mgalazyn/release-tool
diff --git a/.github/workflows/haskell.yml b/.github/workflows/haskell.yml
index 99e67623b0..f48149172b 100644
--- a/.github/workflows/haskell.yml
+++ b/.github/workflows/haskell.yml
@@ -164,26 +164,4 @@ jobs:
           echo 'Build complete'
         fi
 
-  release:
-    needs: [build]
-    if: ${{ startsWith(github.ref, 'refs/tags') }}
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-
-    - name: Create Release Tag
-      id: create_release_tag
-      run: |
-        echo "TAG=${GITHUB_REF/refs\/tags\//}" >> "$GITHUB_OUTPUT"
-
-    - name: Create Release
-      id: create_release
-      uses: actions/create-release@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        tag_name: ${{ github.ref }}
-        release_name: Release ${{ github.ref }}
-        draft: true
-        prerelease: false
+  # Tag-triggered release moved to .github/workflows/release.yml
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000000..b31ddf5479
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,43 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      package:
+        description: 'Package to release (must match a project in .herald.yml)'
+        required: true
+        type: choice
+        options:
+          - cardano-api
+          - cardano-api-gen
+          - cardano-rpc
+          - cardano-wasm
+      version:
+        description: 'Explicit version (A.B.C.D). Leave empty for auto-bump.'
+        required: false
+        type: string
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: cachix/install-nix-action@v30
+        with:
+          nix_path: nixpkgs=channel:nixos-unstable
+          extra_nix_config: |
+            trusted-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ=
+            substituters = https://cache.iog.io/ https://cache.nixos.org/
+
+      - uses: input-output-hk/cardano-dev/herald/.github/actions/release@mgalazyn/release-tool
+        with:
+          package: ${{ inputs.package }}
+          version: ${{ inputs.version }}
+          herald-ref: github:input-output-hk/cardano-dev/mgalazyn/release-tool
diff --git a/.herald.yml b/.herald.yml
new file mode 100644
index 0000000000..dbf6e431d8
--- /dev/null
+++ b/.herald.yml
@@ -0,0 +1,76 @@
+# Herald configuration
+# Changelog and release automation for PVP-versioned Haskell projects
+
+# Git repository in owner/repo format (used for PR links in changelogs)
+git-repo: intersectmbo/cardano-api
+
+# Directory for changelog fragments, relative to repo root
+# Fragments are YAML files created by 'herald new' and consumed by 'herald batch'
+changes-dir: .changes
+
+# Change kinds and their properties
+#
+# Each kind defines:
+#   notable: if true, changes of this kind appear in the changelog
+#           if false, they still bump the version but are omitted from the changelog text
+#   bump:    PVP version component to bump when this kind is present
+#           0.1.0.0 = bump 2nd component (breaking changes)
+#           0.0.1.0 = bump 3rd component (features, compatible changes)
+#           0.0.0.1 = bump 4th component (patches, internal changes)
+#
+# The highest bump across all fragment kinds determines the final version bump.
+kinds:
+  breaking:
+    bump: 0.1.0.0
+    description: the API has changed in a breaking way
+  bugfix:
+    bump: 0.0.0.1
+    description: fixes a defect
+  compatible:
+    bump: 0.0.1.0
+    description: the API has changed but is non-breaking
+  documentation:
+    notable: false
+    bump: 0.0.0.1
+    description: change in code docs, haddocks
+  feature:
+    bump: 0.0.1.0
+    description: introduces a new feature
+  maintenance:
+    notable: false
+    bump: 0.0.0.1
+    description: not directly related to the code
+  optimisation:
+    bump: 0.0.0.1
+    description: measurable performance improvements
+  refactoring:
+    notable: false
+    bump: 0.0.0.1
+    description: code quality improvements
+  release:
+    notable: false
+    bump: 0.0.0.1
+    description: related to a new release preparation
+  test:
+    notable: false
+    bump: 0.0.0.1
+    description: fixes or modifies tests
+
+# Projects in this repository
+#
+# Each project needs:
+#   changelog:  path to the project's CHANGELOG.md (relative to repo root)
+#   cabal-file: (optional) path to the project's .cabal file (version is read/updated here)
+projects:
+  cardano-api:
+    changelog: cardano-api/CHANGELOG.md
+    cabal-file: cardano-api/cardano-api.cabal
+  cardano-api-gen:
+    changelog: cardano-api-gen/CHANGELOG.md
+    cabal-file: cardano-api-gen/cardano-api-gen.cabal
+  cardano-rpc:
+    changelog: cardano-rpc/CHANGELOG.md
+    cabal-file: cardano-rpc/cardano-rpc.cabal
+  cardano-wasm:
+    changelog: cardano-wasm/CHANGELOG.md
+    cabal-file: cardano-wasm/cardano-wasm.cabal
diff --git a/RELEASING.md b/RELEASING.md
index 783e4bce13..9505104fe1 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -1,250 +1,223 @@
 # Versioning and release process
 
+## Prerequisites
+
+Install `herald` from the `cardano-dev` repository:
+
+```bash
+nix run github:input-output-hk/cardano-dev#herald -- --help
+```
+
+Alternatively, enter the `cardano-api` nix-shell where herald is available:
+
+```bash
+nix develop
+```
+
+## Day-to-day: adding changelog fragments
+
+Every PR must include a changelog fragment in `.changes/`. Create one with:
+
+```bash
+herald new
+```
+
+This launches interactive mode, prompting for project, change kind, description, and PR number. You can also pass all fields directly:
+
+```bash
+herald new -p cardano-api -k breaking -d "Remove deprecated API" --pr 1234
+```
+
+CI validates fragments automatically via `herald validate --diff --pr <N>`, which checks that:
+
+- every modified project has at least one fragment
+- fragments are well-formed YAML matching `.herald.yml`
+- the PR number in each new fragment matches the PR
+
 ## Release process
 
-When making a new release, firstly you have to decide on a new version number for the release.
+### 1. Preview the next version
+
+Before starting a release, check what version herald would compute:
+
+```bash
+herald next cardano-api
+```
 
-### Version bumping
-`cardano-api` is using [Haskell Package Versioning Policy](https://pvp.haskell.org/) for numbering each release version.
+This reads the current `.cabal` version, applies the highest bump from unreleased fragments, and prints the result.
 
-In order to decide which version number needs to be bumped up, it is necessary to know what was the latest released version of a package of the specific series you are targeting (e.g., the latest 8.4.x release).
+### 2. Version bumping
 
-Three simple ways are:
-* look at the latest version on [`cardano-haskell-packages` (aka **CHaP**)](https://chap.intersectmbo.org/index.html) - the most reliable way
-* current version in the changelog
-* look at the latest git tag for the version
+`cardano-api` follows the [Haskell Package Versioning Policy](https://pvp.haskell.org/). Herald computes the version bump automatically based on fragment kinds:
 
-When you found out the current version of `cardano-api`, the next step is to find out if the changes within the scope of the release are breaking or not.
-To make this process easier, each pull request has information about that - [see the `compatibility` field in the example changelog here](https://github.com/IntersectMBO/cardano-api/pull/53).
-This information becomes available in the next step of the process, in the changelog preparation after executing `generate-pr-changelogs.sh` script.
-You can defer decision about the version bump to that point.
+- `breaking` -- bump 2nd component (e.g. 8.4.1.2 -> 8.5.0.0)
+- `feature`, `compatible` -- bump 3rd component (e.g. 8.4.1.2 -> 8.4.2.0)
+- `bugfix`, `optimisation`, and all others -- bump 4th component (e.g. 8.4.1.2 -> 8.4.1.3)
 
-In general, the [PVP decision tree](https://pvp.haskell.org/#decision-tree) may become useful in the process.
-For example, if the current version of cardano-api is `8.4.1.2`, you need to bump version to:
-* `8.4.1.3` - if there are only backwards-compatible bug-fixes
-* `8.4.2.0` - if there are only backwards-compatible features or bug-fixes
-* `8.5.0.0` - if there are any breaking changes
-* `9.0.0.0` - for major Cardano releases
+The highest bump across all fragments wins. You can override the computed version with `--version`.
 
-After deciding on the version number, set the correct `version` field in all cabal files in this repo.
+For the current version, check:
+- the `.cabal` file
+- the latest version on [CHaP](https://chap.intersectmbo.org/index.html)
+- the latest git tag
 
-### Changelog preparation
-The changelog preparation workflow is using `cardano-updates` to gather all information and produce the changelog in markdown format.
-The full documentation for scripts is located in [`cardano-updates` repository](https://github.com/IntersectMBO/cardano-updates/blob/master/scripts/README.md).
+### 3. Batch: generate changelog and bump version
 
-This part requires user to have the following tools installed on your local machine:
-* https://github.com/cli/cli
-* https://jqlang.github.io/jq/
-* https://mikefarah.gitbook.io/yq/
+Create a release branch:
 
-Alternatively, you can enter the `cardano-api` nix-shell, where these tools are already available, by running
 ```bash
-nix develop
+git checkout -b release/cardano-api-8.5.0.0
 ```
-in `cardano-api` directory.
 
->:bulb: **Tip**
->
-> Steps which are only required when performing this process for the first time are marked with :four_leaf_clover: .
+> A separate branch is needed for every package you are releasing.
+> For example, to release both `cardano-api` and `cardano-api-gen`, create two branches.
 
-In order to generate changelog files in markdown format use the following steps:
+Run herald to collect fragments, update the changelog, and bump the `.cabal` version:
 
-1. :four_leaf_clover: Clone the `cardano-dev` repo at the same level as `cardano-api`:
-    ```bash
-    git clone https://github.com/input-output-hk/cardano-dev
-    ```
-    Check that you're authenticated to GitHub using GitHub CLI:
-    ```bash
-    gh auth status
-    ```
-    If you're not authenticated, follow the steps shown on the command output.
+```bash
+herald batch cardano-api
+```
 
-1. Create a release branch in `cardano-api`, for example:
-    ```bash
-    git checkout -b release/cardano-api-8.3.0.0
-    ```
-    >:high_brightness: **Note**
-    >
-    >A separate branch needs to be created for every cabal package you're planning to release.
-    >For example if you'd like to release both `cardano-api` and `cardano-api-gen` you need to create two branches (with correct version numbers): `release/cardano-api-8.3.0.0` and `release/cardano-api-gen-8.1.0.0`.
+This will:
+1. Read all `.changes/` fragments for `cardano-api`
+2. Compute the next version (or use `--version A.B.C.D` to override)
+3. Prepend a new section to `cardano-api/CHANGELOG.md`
+4. Update `version:` in `cardano-api/cardano-api.cabal`
+5. Remove the consumed fragment files
 
-1. Download all PRs data from the `cardano-api` repo.
-    This will take some time if the number of all PRs is large. From `cardano-api` directory, run:
-    ```bash
-    ../cardano-dev/scripts/download-prs.sh IntersectMBO/cardano-api
-    ```
-    The downloaded PRs can be inspected in `~/.cache/cardano-updates/` directory.
+To also create a git commit and tag in one step:
 
-    >:high_brightness: **Note**
-    >
-    >It would be advisable to make changelog entries corrections in the descriptions of GitHub PRs itself, as this would let us use GitHub PRs as a single source of truth for the changelog generation process.
-    >This also means, that after making a change to a changelog in a PR description, the whole procedure needs to be restarted from this download step.
-    >The output changelog can be reviewed in the next step.
+```bash
+herald batch cardano-api --commit-tag
+```
 
-1. Generate markdown changelogs from Yaml detail file providing the hash of the previous release tag in the command line argument.
-    For example for the changelog between the tag `cardano-api-8.2.0.0` and `HEAD`:
-    ```bash
-    ../cardano-dev/scripts/generate-pr-changelogs.sh IntersectMBO/cardano-api cardano-api-8.2.0.0..HEAD
-    ```
-    This will process downloaded PRs and use those marked with `feature` or `bug` to produce the changelog to the standard output.
+Or just a commit without the tag:
 
-    >:bulb: **Tip**
-    >
-    >You can sort all tags ascendingly using: `git show-ref --tags --dereference | sort -V -t '/' -k 3,3`
+```bash
+herald batch cardano-api --commit
+```
 
-1. Add generated changelog in the previous step to `CHANGELOG.md` file in respective cabal package in `cardano-api` repository, near the top of the file, adding a new section for the version being prepared, for example: `## 8.3.0.0`.
-    After doing that, create a PR from a new branch back to `master`.
-    Make sure that the release PR contains:
-    * updated changelogs
-    * bumped version fields in cabal files
+Review the generated changelog and create a PR from the release branch back to `master`.
 
->:high_brightness: **Note**
->
->Usually the release PR should only contain a changelog update and a version bump.
->If you are making a release which aims to contain everything from `master` branch, there should be no additional code changes in the release PR.
->An exception to that would be a release with a backported fix for example, where the release PR should contain required code changes too.
+Make sure the release PR contains:
+- updated changelogs
+- bumped version fields in `.cabal` files
+- removed fragment files
 
->:bulb: **Tip**
->
->Hold off on tagging and merging of the release PR, until CHaP PR gets merged. See: p. 5 in [Releasing to `cardano-haskell-packages`](#releasing-to-cardano-haskell-packages).
+> Usually the release PR should only contain a changelog update and a version bump.
+> If you are making a release which aims to contain everything from `master`, there should be no additional code changes.
 
->:bulb: **Tip**
->
->Avoid unnecessary rebasing of the release PR to prevent accidental inclusion of unwanted changes.
->The release PR should be merged using merge queue with an explicit merge commit.
+> Hold off on tagging and merging of the release PR until the CHaP PR gets merged. See step 5.
 
+> Avoid unnecessary rebasing of the release PR to prevent accidental inclusion of unwanted changes.
+> The release PR should be merged using merge queue with an explicit merge commit.
 
-### Releasing to `cardano-haskell-packages`
+### 4. Releasing to `cardano-haskell-packages`
 
-**After verifying the release PR diff** that it contains the correct contents, it should be uploaded to `cardano-haskell-packages` (aka **CHaP**).
+**After verifying the release PR diff** that it contains the correct contents, upload to [CHaP](https://github.com/intersectmbo/cardano-haskell-packages).
 
-Detailed description of the release process is described in [CHaP repository README](https://github.com/intersectmbo/cardano-haskell-packages#how-to-add-a-new-package-version).
-Briefly speaking, it requires executing of the following steps:
+Detailed description is in the [CHaP repository README](https://github.com/intersectmbo/cardano-haskell-packages#how-to-add-a-new-package-version). Briefly:
 
-1. :four_leaf_clover:  Clone `cardano-haskell-packages`:
+1. Clone `cardano-haskell-packages` (first time only):
     ```bash
-    git clone https://github.com/IntersectMBO/cardano-haskell-packages
+    git clone git@github.com:IntersectMBO/cardano-haskell-packages.git
     cd cardano-haskell-packages
     ```
 
-1.  Run the following script, replacing `<commit-hash>` with the just tagged commit hash:
+2. Run the following script, replacing `<commit-hash>` with the tagged commit hash:
     ```bash
     ./scripts/add-from-github.sh https://github.com/IntersectMBO/cardano-api <commit-hash> cardano-api cardano-api-gen
     ```
-    List all packages names for release in the script invocation, after the commit hash like in the example above.
-    The script will create a separate commit for each package.
-
-1. Push your `HEAD` to a new branch, and create a PR in CHaP.
-    An example release PR which you might want to use as a reference: https://github.com/intersectmbo/cardano-haskell-packages/pull/345 .
-
-1. Merge the PR - you don't need additional approvals for that if you belong to the correct GitHub access group.
+    List all package names after the commit hash.
 
-    After package gets released, you can check the released version at: https://chap.intersectmbo.org/all-package-versions/ and update the version in the dependant packages, in their cabal files, for example: `cardano-api ^>= 8.3`
-    Don't forget to bump the CHaP index in cabal.project and flake.lock too.
-    See [`CONTRIBUTING.md` section on updating dependencies](https://github.com/IntersectMBO/cardano-cli/blob/master/CONTRIBUTING.md#updating-dependencies) how to to do so.
+3. Push to a new branch, create a PR in CHaP, and merge it.
 
->:bulb: **Tip**
->
->CHaP CI build can fail due to various reasons, like invalid haddock syntax.
->Tagging and merging the release PR after CHaP PR allows to accommodate for potential issues which can arise here.
+    After the package is released, check the version at https://chap.intersectmbo.org/all-package-versions/ and update dependant packages. Don't forget to bump the CHaP index in `cabal.project` and `flake.lock` too. See [CONTRIBUTING.md](https://github.com/IntersectMBO/cardano-cli/blob/master/CONTRIBUTING.md#updating-dependencies).
 
-### Tagging the release version
+> CHaP CI can fail due to various reasons (e.g. invalid haddock syntax). Tagging after CHaP merge lets you accommodate such issues.
 
-After successful CI build in CHaP, the release PR (in the `cardano-api` repo) can be tagged and then enqueued to merge.
+### 5. Tagging the release version
 
-1. Make sure that:
-   1. Your `HEAD` is on the commit you're going to tag - **this has to be the same commit which was released to CHaP**
-   1. Your `HEAD` is in `release/packagename-version.x` branch history on the `origin` remote (the `.x` suffix is optional).
+After successful CI build in CHaP, tag and enqueue the release PR to merge.
 
-1. Use the following script to prepare the tag:
-   ```bash
-   ../cardano-dev/scripts/tag.sh
-   ```
-   This script will extract the version numbers from cabal files, create the tag and **push it to the `origin` remote**.
-   Please note that the tagging process will fail if either:
-   1. The tag already exists on the origin remote
-   1. The `packagename/CHANGELOG.md` does not contain an entry for the new version.
-
-#### GitHub release pipeline
+If you used `herald batch --commit-tag`, the tag is already created locally. Push it:
 
-If the repo has a release pipeline configured, it will be triggered on the tag push.
+```bash
+git push origin cardano-api-8.5.0.0
+```
 
-1. If the release pipeline (if any, see e.g. [here for CLI](https://github.com/IntersectMBO/cardano-cli/actions/workflows/release-upload.yaml)) fails
-   during the _Get specific check run status_ step of the _Wait for Hydra check-runs_ pipeline, this means Hydra did not
-   run on the tagged commit.
-   This can happen if the tagged commit is not the remote `HEAD` when you create the PR, or if you change the tag after the fact.
+Otherwise, create the tag manually:
 
-   To make hydra run on the tagged commit, checkout this commit, create a branch whose name starts with `ci/`
-   (see [Hydra's code](https://github.com/input-output-hk/hydra-tools/commit/854620a3426957be72fa618c4dfc68f03842617b)) and push this branch.
-   Hydra will pick it up and you can then retrigger release creation as follows (the branch from which you execute this command
-   doesn't matter much): `gh workflow run "Release Upload" -r $(git branch --show-current) -f target_tag=cardano-api-8.2.0.0`.
-1. If a GitHub release is automatically created by the CI, as visible on https://github.com/IntersectMBO/cardano-api/releases,
-   undraft the release by clicking the pen on the top right, then untick _Set as a pre-release_, and
-   finally select _Update release_.
+```bash
+git tag cardano-api-8.5.0.0
+git push origin cardano-api-8.5.0.0
+```
 
-   >:warning: **GitHub bug**
-   >
-   > If you try to undraft a PR using the [gh API](https://docs.github.com/fr/rest/releases/releases?apiVersion=2022-11-28#update-a-release),
-   > you will observe that the `PATCH` endpoint messes up existing metadata of the release (author, associated commit, etc.).
-   > So you HAVE to use the UI, as described above.
+Make sure that:
+- Your `HEAD` is on the commit you are tagging -- **this must be the same commit released to CHaP**
+- Your `HEAD` is in `release/packagename-version.x` branch history on the `origin` remote
 
-## Backporting
+#### GitHub release pipeline
 
-If a bug affecting a release is discovered long after that release has been made (and potentially after several subsequent releases), it may be necessary to create a patch that fixes each of the affected legacy versions. We can achieve this through the following steps:
+If the repo has a release pipeline configured, it is triggered on tag push.
 
-1. Identify the commit that introduced the issue and determine the list of affected releases by checking which tags include that commit (GitHub often displays this list under the commit title).
+1. If the release pipeline fails during _Get specific check run status_ / _Wait for Hydra check-runs_, Hydra did not run on the tagged commit. Create a branch starting with `ci/` from the tagged commit and push it. Then retrigger:
+   ```bash
+   gh workflow run "Release Upload" -r $(git branch --show-current) -f target_tag=cardano-api-8.5.0.0
+   ```
 
-2. Generate a new patch versions for each of the affected releases. New versions are typically calculated by incrementing the third digit of the latest release in each affected series (see the [Version bumping](./RELEASING.md#version-bumping) section for more information). By increasing the third or fourth digit, we ensure dependencies automatically pick up the fix.
+2. If a GitHub release is automatically created, undraft it via the UI: click the pen, untick _Set as a pre-release_, and _Update release_.
 
-3. For each version we decide to patch, create a branch starting from the tag of the unpatched version. For example, for `10.14.2.0`, we create a new branch `release/cardano-api-10.14.2.0` based on the tag `cardano-api-10.14.1.0`.
+   > **GitHub bug**: The `PATCH` API endpoint messes up release metadata (author, commit). Use the UI instead.
 
-4. From each of the release branches, create a dedicated branch for the backported fix, such as `backport/cardano-api-10.14/fix-bug`. Cherry-pick the bug fix onto this backport branch, resolving any conflicts that arise. And issue and merge a Pull Request (PR) from the backport branch to the patch release branch (e.g., `release/cardano-api-10.14.2.0`).
+## Backporting
 
-   The reason we use a PR for the backport is to ensure the changelog gathering script works correctly in later steps. (Alternatively, commits can be added directly to the release branch, but this requires manually writing the changelog entries later.)
+If a bug affecting a release is discovered after subsequent releases, create patch versions:
 
-   This step can be repeated if multiple bugs need to be patched; create one PR per bug fix.
+1. Identify the commit that introduced the issue and determine affected releases.
 
-5. Prepare the releases by generating the changelog entry running the same scripts used for normal releases:
+2. Compute new patch versions by incrementing the fourth digit of the latest release in each affected series.
 
-   ```bash
-    ../cardano-dev/scripts/download-prs.sh IntersectMBO/cardano-api
-    ../cardano-dev/scripts/generate-pr-changelogs.sh IntersectMBO/cardano-api cardano-api-10.14.1.0..HEAD
+3. For each affected version, create a branch from its tag:
+    ```bash
+    git checkout -b release/cardano-api-10.14.2.0 cardano-api-10.14.1.0
     ```
 
-   Add the generated entry to the `CHANGELOG.md`, bump the version number in the `.cabal` file, and create a release PR targeting `master`.
+4. Cherry-pick fixes via PRs into each release branch. Each fix PR should include a `herald new` fragment as usual.
 
-6. Publish the releases to CHaP (Cardano Haskell Packages) in the same way than for normal releases (see [Releasing to `cardano-haskell-packages`](./RELEASING.md#releasing-to-cardano-haskell-packages) section): Use `add-from-github.sh` to create a CHaP entry for each of our new releases, open a PR in the CHaP repository, and once the build passes and is approved, we merge them.
+5. From the release branch, batch the changelog:
+    ```bash
+    herald batch cardano-api --commit-tag
+    ```
 
-7. Use `tag.sh` to create a release tag in the repo of the package we are fixing.
+6. Publish to CHaP as in the normal release process.
 
-8. Unlike in the release workflow for normal releases, for backports, we will **not** merge the release PR into `master` (assuming the backported fix is already there). Attempting to do so may cause issues with conflicts, CI errors, and the risk of the same changes being applied several times to `master`.
+7. Push the tag:
+    ```bash
+    git push origin cardano-api-10.14.2.0
+    ```
 
-   Instead, we will just close the backport release PRs and open a new PR, directly forked from `master`, that will simply update the change-log for all the release PRs we haven't merged. This should be done just once for all the releases, after all the patches have been released.
+8. Unlike normal releases, **do not merge** backport release PRs into `master` (the fix is already there). Close the backport PRs and open one PR from `master` that updates the changelog for all closed backport releases.
 
 ## Troubleshooting
 
 ### Build fails due to `installed package instance does not exist`
-If you notice that your build fails due to an error similar to the following one:
+If your build fails with an error like:
 ```
- Configuring library for cardano-ledger-conway-1.8.0.0..
+Configuring library for cardano-ledger-conway-1.8.0.0..
 Error: cabal: The following package dependencies were requested
---dependency='cardano-ledger-alonzo=cardano-ledger-alonzo-1.4.1.0-b1d2cdacf3fecf8f57f465701c6cc39a19521597ceee354f7a1ea4688dec9d9f'
---dependency='cardano-ledger-babbage=cardano-ledger-babbage-1.4.4.0-3f75b69fa5a14215f31de708afe86d5d69fbecea8ff284dc3265e0701eada7b6'
+--dependency='cardano-ledger-alonzo=...'
 however the given installed package instance does not exist.
 ```
 increase the cabal cache version number in [.github/workflows/haskell.yml](.github/workflows/haskell.yml):
 ```yaml
 CABAL_CACHE_VERSION: "2023-08-22"
 ```
-Usually setting this date to the current date is enough.
-If it is already set to the current date, you can add a suffix to it - the important part is to make it unique across all builds which occurred until now, for example `2023-08-22-1`.
-This issue happens due to frequent cache collisions in the [`cabal-cache`](https://github.com/haskell-works/cabal-cache).
+Setting this date to the current date is usually enough. If it is already the current date, add a suffix (e.g. `2023-08-22-1`). This happens due to cache collisions in [`cabal-cache`](https://github.com/haskell-works/cabal-cache).
 
 ## References
-1. https://github.com/input-output-hk/cardano-updates/tree/master/scripts
 1. https://github.com/IntersectMBO/cardano-ledger/blob/master/RELEASING.md
 1. https://chap.intersectmbo.org/index.html
 1. https://input-output-hk.github.io/cardano-engineering-handbook/policy/haskell/packaging/versioning.html
 
 <!-- vim: set spell textwidth=0: -->
-
diff --git a/cardano-api/src/Cardano/Api/Pretty.hs b/cardano-api/src/Cardano/Api/Pretty.hs
index 30ba6ad79b..8947d7aadc 100644
--- a/cardano-api/src/Cardano/Api/Pretty.hs
+++ b/cardano-api/src/Cardano/Api/Pretty.hs
@@ -12,6 +12,7 @@ module Cardano.Api.Pretty
   , renderBuildable
   , textShow
   , pshow
+  , pshow2
   , prettyException
   , hsep
   , vsep
@@ -89,6 +90,11 @@ white = annotate (color White)
 pshow :: Show a => a -> Doc ann
 pshow = viaShow
 
+
+-- | Short hand for 'viaShow'.
+pshow2 :: Show a => a -> Doc ann
+pshow2 = viaShow
+
 -- | Short hand for @'pretty' . 'displayException'@
 prettyException :: Exception a => a -> Doc ann
 prettyException = pretty . displayException