diff --git a/MAINTAINERS b/MAINTAINERS
index a99a49b..4461f61 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -27,6 +27,7 @@
 arch-alpha:
 arch-arm:
   Andreas Sandberg <andreas.sandberg@arm.com>
+  Giacomo Travaglini <giacomo.travaglini@arm.com>
 arch-hsail:
   Tony Gutierrez <anthony.gutierrez@amd.com>
 arch-mips:
@@ -54,6 +55,10 @@
 dev-virtio:
   Andreas Sandberg <andreas.sandberg@arm.com>
 
+dev-arm:
+  Andreas Sandberg <andreas.sandberg@arm.com>
+  Giacomo Travaglini <giacomo.travaglini@arm.com>
+
 ext: Components external to gem5
 
 gpu-compute:
@@ -93,6 +98,7 @@
 system-alpha:
 system-arm:
   Andreas Sandberg <andreas.sandberg@arm.com>
+  Giacomo Travaglini <giacomo.travaglini@arm.com>
 
 tests: testing changes (not stats updates for tests. See stats:)
   Andreas Sandberg <andreas.sandberg@arm.com>
