diff --git a/CHANGELOG.md b/CHANGELOG.md
index e19a87ce4..97b3cb4e4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,15 @@
+## [Unreleased]
+
+### Added
+- **PeTTa Integration**: MeTTa smart contract execution via SWI-Prolog
+  - New system contract URN `rho:petta:execute` for executing MeTTa code from Rholang
+  - Core execution function `petta_execute()` with 10-second timeout protection
+  - Example contracts in `rholang/examples/system-contract/swipl/` demonstrating pattern matching and recursion
+  - Full documentation:
+    - URN specification: `rholang/docs/PETTA_URN_SPECIFICATION.md`
+    - Test documentation: `rholang/tests/PETTA_TESTS_SUMMARY.md` and `TIMEOUT_TESTS.md`
+    - Example README: `rholang/examples/system-contract/swipl/README.md`
+    - API documentation via doc comments on all public items
 
 ## [v0.1.0-SNAPSHOT] - 2023-05-15
 - Added new features
diff --git a/DEVELOPER.md b/DEVELOPER.md
index 13e6a722c..d8b66e6d0 100644
--- a/DEVELOPER.md
+++ b/DEVELOPER.md
@@ -5,6 +5,14 @@ __Note__ Successfully building from source requires attending to all of the prer
 ### Prerequisites
 
 * [Environment set up](README.md#installation).
+* **SWI-Prolog** - Required runtime dependency for MeTTa smart contract execution via PeTTa submodule
+  - Nix/direnv users: Already provisioned in the development shell
+  - Manual installation:
+    - macOS: `brew install swi-prolog`
+    - Ubuntu/Debian: `apt-get install swi-prolog`
+    - Fedora: `dnf install pl`
+  - The `swipl` binary must be in your PATH
+  - PeTTa submodule must be initialized: `git submodule update --init --recursive`
 
 <!-- Setup using _nix_ can be found in the [nix](./nix) directory.
 
diff --git a/flake.nix b/flake.nix
index f211b1975..43f8d1632 100644
--- a/flake.nix
+++ b/flake.nix
@@ -149,6 +149,11 @@
               package = just;
               help = "Just command runner for local development tasks";
             }
+            {
+              name = "swipl";
+              package = swi-prolog;
+              help = "SWI-Prolog interpreter (required for PeTTa/MeTTa execution)";
+            }
           ];
           packages = [
             # Required for Python packages with native extensions (grpcio, etc.)
@@ -188,6 +193,10 @@
                 name = "BLOOP_JAVA_OPTS";
                 value = "-Xmx4G -XX:+UseZGC -Xss4m -Xms1g";
               }
+              {
+                name = "PETTA_PATH";
+                value = "./PeTTa";
+              }
             ];
         };
       }
diff --git a/node/Dockerfile b/node/Dockerfile
index 5fbb85444..9f4011285 100644
--- a/node/Dockerfile
+++ b/node/Dockerfile
@@ -61,6 +61,9 @@ COPY comm/ ./comm/
 COPY rholang/ ./rholang/
 COPY node/ ./node/
 
+# Copy PeTTa submodule (required for MeTTa contract execution)
+COPY PeTTa/ ./PeTTa/
+
 # Configure pkg-config for cross-compilation to find target OpenSSL libraries
 # xx-apt installs target libs in the xx sysroot, we need to tell pkg-config where they are
 # Enable AES CPU features for gxhash dependency (required by PathMap crate).
@@ -88,12 +91,14 @@ FROM debian:bookworm-slim AS runtime-base
 
 # Install runtime dependencies
 # Note: grpcurl and jq for healthcheck (matching build.sbt healthcheck)
+# Note: swi-prolog is required for PeTTa/MeTTa contract execution
 RUN apt-get update && apt-get install -y \
     ca-certificates \
     libssl3 \
     libc6 \
     libjemalloc2 \
     curl \
+    swi-prolog \
     && rm -rf /var/lib/apt/lists/*
 
 # Install grpcurl and jq for healthcheck (matching build.sbt)
@@ -149,6 +154,9 @@ COPY --from=builder /build/casper/src/main/resources ./casper/src/main/resources
 # Copy rholang examples (matching build.sbt: directory((baseDirectory in rholang).value / "examples"))
 COPY --from=builder /build/rholang/examples ./examples
 
+# Copy PeTTa submodule (required for MeTTa contract execution at runtime)
+COPY --from=builder /build/PeTTa ./PeTTa
+
 # Create entrypoint script for Rust (adapted from docker-entrypoint.sh)
 # Copy the Rust-specific entrypoint script from node directory
 # Note: This Dockerfile should be built from workspace root
@@ -176,6 +184,9 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
 LABEL maintainer="F1r3fly.io LCA https://f1r3fly.io/"
 LABEL version="0.1.0"
 
+# Set PETTA_PATH environment variable for MeTTa contract execution
+ENV PETTA_PATH=/opt/docker/PeTTa
+
 # Switch to daemon user (matching build.sbt: daemonUser in Docker := "daemon")
 USER daemon
 
diff --git a/rholang/examples/system-contract/swipl/01-compile-metta.rho b/rholang/examples/system-contract/swipl/01-compile-metta.rho
deleted file mode 100644
index cd75e78bc..000000000
--- a/rholang/examples/system-contract/swipl/01-compile-metta.rho
+++ /dev/null
@@ -1,6 +0,0 @@
-new compilePetta(`rho:petta:compile`), stdout(`rho:io:stdout`), retCh in {
-  compilePetta!("(= (swap (Pair $x $y)) (Pair $y $x))", *retCh) |
-  for(@ok <- retCh) {
-      stdout!(ok)
-  }
-}
\ No newline at end of file
diff --git a/rholang/examples/system-contract/swipl/01-swap.metta b/rholang/examples/system-contract/swipl/01-swap.metta
new file mode 100644
index 000000000..ebc40185c
--- /dev/null
+++ b/rholang/examples/system-contract/swipl/01-swap.metta
@@ -0,0 +1,9 @@
+(p 1 2)
+(p x y)
+
+(= (swap (Pair $x $y)) (Pair $y $x))
+
+; Mandatory entry point with dummy parameter (unused)
+(= (main $_)
+   (match &self (p $a $b) (swap (Pair $a $b)))
+)
diff --git a/rholang/examples/system-contract/swipl/01-swap.rho b/rholang/examples/system-contract/swipl/01-swap.rho
new file mode 100644
index 000000000..215857652
--- /dev/null
+++ b/rholang/examples/system-contract/swipl/01-swap.rho
@@ -0,0 +1,6 @@
+new executePetta(`rho:petta:execute`), stdout(`rho:io:stdout`), retCh in {
+  executePetta!("(p 1 2) (p x y) (= (swap (Pair $x $y)) (Pair $y $x)) (= (main $_) (match &self (p $a $b) (swap (Pair $a $b))))", *retCh) |
+  for(@ok <- retCh) {
+      stdout!(ok)
+  }
+}
diff --git a/rholang/examples/system-contract/swipl/02-fib-long.metta b/rholang/examples/system-contract/swipl/02-fib-long.metta
new file mode 100644
index 000000000..cc702e1e5
--- /dev/null
+++ b/rholang/examples/system-contract/swipl/02-fib-long.metta
@@ -0,0 +1,13 @@
+(= (fib-tr $n $a $b)
+   (if (== $n 0)
+       $a
+       (fib-tr (- $n 1) $b (+ $a $b))))
+
+(= (fib $n)
+   (fib-tr $n 0 1))
+
+(= (main $_) (fib 1000000))
+
+!(main dummy)
+
+
diff --git a/rholang/examples/system-contract/swipl/02-fib-long.rho b/rholang/examples/system-contract/swipl/02-fib-long.rho
new file mode 100644
index 000000000..58bb2bdea
--- /dev/null
+++ b/rholang/examples/system-contract/swipl/02-fib-long.rho
@@ -0,0 +1,6 @@
+new executePetta(`rho:petta:execute`), stdout(`rho:io:stdout`), retCh in {
+  executePetta!("(= (fib-tr $n $a $b) (if (== $n 0) $a (fib-tr (- $n 1) $b (+ $a $b)))) (= (fib $n) (fib-tr $n 0 1)) (= (main $x) (fib 1000000)) !(main dummy)", *retCh) |
+  for(@ok <- retCh) {
+      stdout!(ok)
+  }
+}
diff --git a/rholang/examples/system-contract/swipl/02-fibonacci-long.metta b/rholang/examples/system-contract/swipl/02-fibonacci-long.metta
new file mode 100644
index 000000000..13d687c3b
--- /dev/null
+++ b/rholang/examples/system-contract/swipl/02-fibonacci-long.metta
@@ -0,0 +1,9 @@
+(= (fib-tr $n $a $b)
+   (if (== $n 0)
+       $a
+       (fib-tr (- $n 1) $b (+ $a $b))))
+
+(= (fib $n)
+   (fib-tr $n 0 1))
+
+(= (main $_) (fib 1000000))
diff --git a/rholang/examples/system-contract/swipl/02-fibonacci-long.rho b/rholang/examples/system-contract/swipl/02-fibonacci-long.rho
new file mode 100644
index 000000000..7665f2cf2
--- /dev/null
+++ b/rholang/examples/system-contract/swipl/02-fibonacci-long.rho
@@ -0,0 +1,6 @@
+new executePetta(`rho:petta:execute`), stdout(`rho:io:stdout`), retCh in {
+  executePetta!("(= (fib-tr $n $a $b) (if (== $n 0) $a (fib-tr (- $n 1) $b (+ $a $b)))) (= (fib $n) (fib-tr $n 0 1)) (= (main $_) (fib 1000000))", *retCh) |
+  for(@ok <- retCh) {
+      stdout!(ok)
+  }
+}
diff --git a/rholang/examples/system-contract/swipl/README.md b/rholang/examples/system-contract/swipl/README.md
new file mode 100644
index 000000000..11967d2f8
--- /dev/null
+++ b/rholang/examples/system-contract/swipl/README.md
@@ -0,0 +1,143 @@
+# PeTTa (SWI-Prolog + MeTTa) Examples
+
+This directory contains Rholang examples demonstrating the `rho:petta:execute`
+system contract, which provides access to the MeTTA language.
+
+## What is PeTTa?
+
+**PeTTa** is an interpreter for MeTTa written in SWI-Prolog.
+
+This integration allows Rholang contracts to perform advanced symbolic reasoning,
+pattern matching, and AI-style computations.
+
+## Prerequisites
+
+See the prerequisites section in the DEVELOPER.md file located in the project's
+folder.
+
+## MeTTa entry point
+
+Standard MeTTa programs do not require an entry point. Any definitions and queries
+are added and executed (respectively) in the order of the program.
+
+However, programs provided to the `rho::petta::execute` contract MUST contain
+an entry point called `main`. This entry point MUST be defined as a function
+with a single parameter (which serves no purpose and should be ignored).
+
+## Examples Overview
+
+### 01-swap.rho - Pattern Matching Basics
+
+Demonstrates basic MeTTa pattern matching by defining a `swap` function that reverses a pair.
+
+### 02-fib-long.rho - Recursive Computation
+
+Computes a large Fibonacci number (fib(1000000)) using tail recursion,
+which on consumer hardware should exceed the timeout of 10 seconds currently
+defined for all MeTTa computations.
+
+
+**MeTTa code:**
+```metta
+(= (fib-tr $n $a $b) (if (== $n 0) $a (fib-tr (- $n 1) $b (+ $a $b))))
+(= (fib $n) (fib-tr $n 0 1))
+!(fib 1000000)
+```
+
+### Return Value Structure
+
+PeTTa always returns results wrapped in a `{"results": [...]}` JSON object, which is converted to a Rholang map:
+
+```rholang
+{
+  "results": [result1, result2, ...]  // Rholang list
+}
+```
+
+## Common Patterns
+
+### Pattern 1: Simple Computation
+
+```rholang
+new executePetta(`rho:petta:execute`), retCh in {
+  executePetta!("!(+ 1 2)", *retCh) |
+  for(@result <- retCh) {
+    // result = {"results": [3]}
+    match result {
+      {"results": [answer]} => {
+        stdout!(answer)  // Prints: 3
+      }
+    }
+  }
+}
+```
+
+### Pattern 2: Multiple Calls
+
+```rholang
+new executePetta(`rho:petta:execute`), ret1, ret2 in {
+  executePetta!("!(+ 1 2)", *ret1) |
+  executePetta!("!(* 3 4)", *ret2) |
+  
+  for(@r1 <- ret1; @r2 <- ret2) {
+    stdout!([r1, r2])
+  }
+}
+```
+
+## Troubleshooting
+
+### Error: "Can't find PeTTa"
+
+**Cause:** `$PETTA_PATH` points to invalid location
+
+**Solution:**
+```bash
+# Check PeTTa location
+ls ./PeTTa/src/metta.pl
+
+# Or set explicitly
+export PETTA_PATH=/full/path/to/PeTTa
+```
+
+### Error: "swipl: command not found"
+
+**Cause:** SWI-Prolog not installed or not in PATH
+
+**Solution:**
+```bash
+# Install SWI-Prolog
+brew install swi-prolog  # macOS
+apt-get install swi-prolog  # Ubuntu/Debian
+
+# Verify
+which swipl
+```
+
+### Timeout Errors
+
+**Cause:** Computation exceeded 10-second limit
+
+**Solutions:**
+1. Break computation into smaller steps
+2. Use more efficient algorithms
+3. Pre-compute complex results off-chain
+
+### No Output
+
+**Cause:** Error occurred (doesn't send on ack channel)
+
+**Solution:** Check node logs for error details:
+```bash
+tail -f ~/.rnode/rnode.log
+```
+
+## Security Notes
+
+⚠️ **Important Security Considerations: this feature is EXPERIMENTAL.**
+
+1. **Untrusted Code:** Never execute untrusted MeTTa code - there is currently
+   no sandboxing at language level
+2. **Timeouts:** All execution limited to 10 seconds to prevent DoS
+3. **Non-Deterministic:** Results are cached for replay (consensus safety)
+4. **Resource Limits:** System memory limits apply
diff --git a/rholang/src/rust/interpreter/rho_runtime.rs b/rholang/src/rust/interpreter/rho_runtime.rs
index e3cd87314..8aa3209c4 100644
--- a/rholang/src/rust/interpreter/rho_runtime.rs
+++ b/rholang/src/rust/interpreter/rho_runtime.rs
@@ -1026,26 +1026,21 @@ fn std_rho_chroma_processes() -> Vec<Definition> {
 }
 
 fn std_swipl_processes() -> Vec<Definition> {
-    vec![
-        Definition {
-            urn: "rho:petta:compile".to_string(),
-            fixed_channel: FixedChannels::swipl_compile_petta(),
-            arity: 2,
-            body_ref: BodyRefs::SWIPL_COMPILE_PETTA,
-            handler: Box::new(|ctx| {
-                Box::new(move |args| {
-                    let ctx = ctx.clone();
-                    Box::pin(async move {
-                        ctx.system_processes
-                            .clone()
-                            .swipl_compile_petta(args)
-                            .await
-                    })
-                })
-            }),
-            remainder: None,
-        },
-    ]
+    vec![Definition {
+        urn: "rho:petta:execute".to_string(),
+        fixed_channel: FixedChannels::swipl_execute_petta(),
+        arity: 2,
+        body_ref: BodyRefs::SWIPL_EXECUTE_PETTA,
+        handler: Box::new(|ctx| {
+            Box::new(move |args| {
+                let ctx = ctx.clone();
+                Box::pin(
+                    async move { ctx.system_processes.clone().swipl_execute_petta(args).await },
+                )
+            })
+        }),
+        remainder: None,
+    }]
 }
 
 fn dispatch_table_creator(
diff --git a/rholang/src/rust/interpreter/swi_prolog_service.rs b/rholang/src/rust/interpreter/swi_prolog_service.rs
index 7145463d3..9284285f7 100644
--- a/rholang/src/rust/interpreter/swi_prolog_service.rs
+++ b/rholang/src/rust/interpreter/swi_prolog_service.rs
@@ -1,39 +1,549 @@
-use std::env;
+use crypto::rust::hash::blake2b256::Blake2b256;
+use hex::ToHex;
+use models::rhoapi::Par;
+use serde_json::Value;
+use std::fs::{create_dir_all, remove_dir_all, File, OpenOptions};
 use std::io::Write;
-use std::path::Path;
-use std::process::Command;
+use std::path::{Path, PathBuf};
+use std::{env, time::Duration};
+use tokio::process::Command;
 
-use tempfile::NamedTempFile;
+use crate::rust::interpreter::rho_type::{
+    RhoBoolean, RhoList, RhoMap, RhoNil, RhoNumber, RhoString,
+};
 
 use super::errors::InterpreterError;
 
-pub fn evaluate(_swi_prolog_code: &str) -> Result<(), InterpreterError> {
-    Ok(())
+// TODO: Place `petta_sessions` in location where f1r3node state is persisted.
+// A PettaSession holds the MeTTa program to execute and any continuations created
+// during its execution. It must be cleaned up whenever execution succeeds or is
+// aborted due to an `InterpreterError`. It must outlive other problems such as
+// power outages or the f1r3node process being killed.
+struct PettaSession {
+    path: PathBuf,
 }
 
-pub fn petta_compile(metta_code: &str) -> Result<String, InterpreterError> {
-    // Write the MeTTa code to a temp file
-    let mut metta_file = NamedTempFile::new()
-        .map_err(|_| InterpreterError::SwiplError("Can't open temp file".into()))?;
-    metta_file.write(metta_code.as_bytes())
-        .map_err(|_| InterpreterError::SwiplError("Can't write MeTTa code to temp file".into()))?;
+impl PettaSession {
+    fn create(metta_source: &str) -> Result<Self, InterpreterError> {
+        let hash: String = Blake2b256::hash(Vec::from(metta_source.as_bytes())).encode_hex_upper();
+        let petta_sessions_path = Path::new("petta_sessions");
+        let this_session_path = petta_sessions_path.join(Path::new(hash.as_str()));
+        let this_program_path = this_session_path.join(Path::new("program.metta"));
+        // Create sessions dir
+        create_dir_all(&this_session_path)?;
+        // Copy wrapped program into session dir
+        let file = OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(this_program_path)?;
+        write_metta_program(metta_source, file)?;
+        // Symlink repos folder. `git-import!` in MeTTa downloads repositories
+        // into the current working directory, but this will happen constantly
+        // because session folders are transient.
+        // TODO: Add a standard location for downloaded repositories.
+        let repos_path = Path::new("../../repos");
+        let repos_symlink = this_session_path.join(Path::new("repos"));
+        std::os::unix::fs::symlink(repos_path, repos_symlink)?;
+        Ok(Self {
+            path: this_session_path,
+        })
+    }
+}
+
+impl Drop for PettaSession {
+    fn drop(&mut self) {
+        remove_dir_all(&self.path).unwrap_or_else(|e| {
+            println!(
+                "Failed to delete session folder {:#?}. Error {:#?}",
+                self.path, e
+            )
+        });
+    }
+}
+
+/// Executes MeTTa code through the PeTTa (SWI-Prolog) interpreter and returns the result as a Rholang Par.
+///
+/// # Overview
+///
+/// This function provides low-level access to the PeTTa interpreter, which
+/// provides MeTTa execution with SWI-Prolog. The execution is sandboxed with
+/// a 10-second timeout to prevent runaway computations.
+///
+/// # Arguments
+///
+/// * `metta_code` - A string containing valid MeTTa code to execute
+///
+/// # Returns
+///
+/// Returns `Ok(Par)` containing the execution result as a Rholang Par structure, or an
+/// `InterpreterError::SwiplError` if execution fails.
+///
+/// # JSON Output Schema
+///
+/// PeTTa returns results as JSON in the following envelope:
+/// ```json
+/// {"results": [...]}
+/// ```
+///
+/// The `results` field contains a JSON array of MeTTa execution results. This entire JSON
+/// structure is converted to a Rholang Par using the following mapping:
+///
+/// - `null` → `RhoNil`
+/// - `true`/`false` → `RhoBoolean`
+/// - Numbers → `RhoNumber` (must fit in i64, otherwise error)
+/// - Strings → `RhoString`
+/// - Arrays → `RhoList` (recursive conversion of elements)
+/// - Objects → `RhoMap` (keys converted to RhoString, values recursively converted)
+///
+/// # Error Conditions
+///
+/// - `InterpreterError::SwiplError("Can't find PeTTa.")` - PeTTa installation not found at `$PETTA_PATH`
+/// - `InterpreterError::SwiplError("Can't open temp file")` - Failed to create temporary file
+/// - `InterpreterError::SwiplError("MeTTa execution timed out...")` - Execution exceeded 10 seconds
+/// - `InterpreterError::SwiplError("PeTTa execution failed...")` - SWI-Prolog returned error
+/// - `InterpreterError::SwiplError("Can't parse JSON output...")` - Invalid JSON from PeTTa
+/// - `InterpreterError::SwiplError("Could not parse number as i64")` - Number exceeds i64 range
+///
+/// # Environment Variables
+///
+/// - `PETTA_PATH` - Path to PeTTa installation directory (default: `./PeTTa`)
+///
+/// # Timeout
+///
+/// Execution is limited to 10 seconds. Long-running computations will be terminated and return
+/// a timeout error. This prevents malicious or buggy MeTTa code from blocking the node.
+///
+/// # Examples
+///
+/// ```ignore
+/// // Simple arithmetic
+/// let result = petta_execute("!(+ 1 2)").await?;
+///
+/// // Pattern matching
+/// let result = petta_execute(
+///     "(= (swap (Pair $x $y)) (Pair $y $x)) !(swap (Pair 1 3))"
+/// ).await?;
+/// ```
+///
+/// # See Also
+///
+/// - [`system_processes::swipl_execute_petta`] - System process wrapper for Rholang contracts
+/// - [`value_to_par`] - JSON to Par conversion logic
+
+pub async fn petta_execute(metta_code: &str) -> Result<Par, InterpreterError> {
+    let session = PettaSession::create(metta_code)?;
 
     // Get the path to PeTTa
-    let petta_path = env::var("PETTA_PATH")
-        .unwrap_or("./PeTTa/src/main.pl".into());
-    let petta_path = Path::new(&petta_path);
-    if !petta_path.exists() {
+    let metta_module_path: PathBuf = {
+        let petta_path = PathBuf::from(env::var("PETTA_PATH").unwrap_or("./PeTTa".into()));
+        [petta_path, PathBuf::from("src/metta.pl")].iter().collect()
+    };
+
+    if !metta_module_path.exists() {
         return Err(InterpreterError::SwiplError("Can't find PeTTa.".into()));
     }
 
-    // Execute PeTTa
-    let output = Command::new("swipl")
-        .arg(petta_path)
-        .arg(metta_file.path())
-        .output()
-        .map_err(|_| InterpreterError::SwiplError("Can't translate MeTTa with PeTTa".into()))?;
+    // We need to do some manual setup before running the MeTTa program. Some of
+    // these steps are done by the main entry point of the PeTTa program, but others
+    // are not.
+    //
+    // We also run some additional code after the evaluation of the MeTTa program
+    // to get useful output that we can parse.
+    let goal = format!(
+        r#"assertz(silent(true)),
+           working_directory(_, '{session_path}'),
+           assertz(working_dir('{session_path}')),
+           load_metta_file('program.metta', Results),
+           use_module(library(json)),
+           json_write_dict(current_output, #{{results:Results}})."#,
+        session_path = session.path.display()
+    );
+
+    // TODO: Make this a configuration parameter
+    let timeout_secs: u64 = 10;
+    let proc_handle = tokio::spawn(tokio::time::timeout(
+        Duration::from_secs(timeout_secs),
+        Command::new("swipl")
+            .arg("-s")
+            .arg(metta_module_path)
+            .arg("-g")
+            .arg(goal)
+            .arg("-t")
+            .arg("halt")
+            .kill_on_drop(true)
+            .output(),
+    ));
+
+    let output = proc_handle
+        .await
+        .map_err(|join_error| {
+            InterpreterError::SwiplError(
+                format!("Error while joining with the PeTTa task: {}", join_error).into(),
+            )
+        })?
+        .map_err(|elapsed| {
+            InterpreterError::SwiplError(
+                format!("MeTTa execution timed out after {}", elapsed).into(),
+            )
+        })?
+        .map_err(|e| {
+            InterpreterError::SwiplError(format!("MeTTa execution failed: {}", e).into())
+        })?;
+
+    if !output.status.success() {
+        return Err(InterpreterError::SwiplError(
+            format!("PeTTa execution failed. {:#?}", output.stderr.as_slice()).into(),
+        ));
+    }
 
     // Get output as string
-    String::from_utf8(output.stdout)
-        .map_err(|_| InterpreterError::SwiplError("Can't interpret PeTTa output".into()))
-}
\ No newline at end of file
+    let str_output = String::from_utf8(output.stdout)
+        .map_err(|_| InterpreterError::SwiplError("Can't interpret PeTTa output".into()))?;
+
+    let value_output = serde_json::from_str::<Value>(str_output.as_str()).map_err(|_| {
+        InterpreterError::SwiplError("Can't parse JSON output from PeTTa execution".into())
+    })?;
+    let par_output = value_to_par(value_output)?;
+    Ok(par_output)
+}
+
+/// Converts a JSON Value to a Rholang Par structure.
+///
+/// This function recursively transforms JSON data returned by PeTTa into Rholang's internal
+/// representation (Par). It is used internally by [`petta_execute`] to convert PeTTa results.
+///
+/// # Type Mapping
+///
+/// | JSON Type | Rholang Type | Notes |
+/// |-----------|--------------|-------|
+/// | `null` | `RhoNil` | Represents absence of value |
+/// | `boolean` | `RhoBoolean` | Direct mapping |
+/// | `number` | `RhoNumber` | **Must fit in i64**, otherwise returns error |
+/// | `string` | `RhoString` | Direct mapping, supports Unicode |
+/// | `array` | `RhoList` | Elements recursively converted |
+/// | `object` | `RhoMap` | Keys stringified, values recursively converted |
+///
+/// # Important Constraints
+///
+/// - **Numbers must fit in i64**: JSON numbers that exceed `i64::MIN` to `i64::MAX` will cause
+///   an error. Floating-point numbers are truncated to integers.
+/// - **Object keys become strings**: All JSON object keys are converted to `RhoString` in the
+///   resulting `RhoMap`.
+/// - **Recursive conversion**: Nested structures (arrays in arrays, objects in objects, etc.)
+///   are fully supported and recursively converted.
+///
+/// # Arguments
+///
+/// * `v` - A `serde_json::Value` to convert
+///
+/// # Returns
+///
+/// Returns `Ok(Par)` with the converted structure, or `InterpreterError::SwiplError` if
+/// conversion fails (e.g., number doesn't fit in i64).
+///
+/// # Examples
+///
+/// ```ignore
+/// use serde_json::json;
+///
+/// // Simple values
+/// let nil = value_to_par(json!(null))?;
+/// let bool = value_to_par(json!(true))?;
+/// let num = value_to_par(json!(42))?;
+/// let str = value_to_par(json!("hello"))?;
+///
+/// // Collections
+/// let list = value_to_par(json!([1, 2, 3]))?;
+/// let map = value_to_par(json!({"key": "value"}))?;
+///
+/// // Nested structures
+/// let nested = value_to_par(json!({
+///     "list": [1, 2, 3],
+///     "map": {"inner": "value"}
+/// }))?;
+/// ```
+fn value_to_par(v: Value) -> Result<Par, InterpreterError> {
+    match v {
+        Value::Null => Ok(RhoNil::create_par()),
+        Value::Bool(b) => Ok(RhoBoolean::create_par(b)),
+        Value::Number(n) => {
+            let n64 = n.as_i64().ok_or(InterpreterError::SwiplError(
+                "Could not parse number as i64".into(),
+            ))?;
+            Ok(RhoNumber::create_par(n64))
+        }
+        Value::String(s) => Ok(RhoString::create_par(s)),
+        Value::Array(values) => {
+            let ps = values
+                .into_iter()
+                .map(value_to_par)
+                .collect::<Result<_, _>>()?;
+            Ok(RhoList::create_par(ps))
+        }
+        Value::Object(map) => {
+            let hashmap = map
+                .into_iter()
+                .map(|(k, v)| {
+                    let p = value_to_par(v)?;
+                    Ok((RhoString::create_par(k), p))
+                })
+                .collect::<Result<_, InterpreterError>>()?;
+            Ok(RhoMap::create_par(hashmap))
+        }
+    }
+}
+
+// This function wraps the given MeTTa program to support snapshots and persists
+// the wrapped version of the program to the given file.
+fn write_metta_program(metta_code: &str, mut file: File) -> Result<(), std::io::Error> {
+    let prelude = r#"!(progn
+    (import! &self (library lib_import))
+    (call (git-import! "https://github.com/rmgaray/petta_lib_snapshot.git"))
+    (import! &self (library lib_snapshot))
+    (empty)
+)
+"#;
+    let main_wrapper = r#"
+!(progn
+     (InjectSnapshots)
+     (CallWithSnapshotInterval (main dummy) 200000)
+)
+"#;
+    file.write_all(prelude.as_bytes())?;
+    file.write_all(metta_code.as_bytes())?;
+    file.write_all(main_wrapper.as_bytes())
+}
+
+///// TESTS /////
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    #[test]
+    fn test_value_to_par_null() {
+        let result = value_to_par(json!(null)).unwrap();
+        assert_eq!(result, RhoNil::create_par());
+    }
+    #[test]
+    fn test_value_to_par_boolean() {
+        let result = value_to_par(json!(true)).unwrap();
+        assert_eq!(result, RhoBoolean::create_par(true));
+    }
+    #[test]
+    fn test_value_to_par_small_number() {
+        let result = value_to_par(json!(42)).unwrap();
+        assert_eq!(result, RhoNumber::create_par(42));
+    }
+    #[test]
+    fn test_value_to_par_max_i64() {
+        let result = value_to_par(json!(i64::MAX)).unwrap();
+        assert_eq!(result, RhoNumber::create_par(i64::MAX));
+    }
+    #[test]
+    fn test_value_to_par_string() {
+        let result = value_to_par(json!("hello")).unwrap();
+        assert_eq!(result, RhoString::create_par("hello".into()));
+    }
+    #[test]
+    fn test_value_to_par_array() {
+        let result = value_to_par(json!([1, "two", true])).unwrap();
+        assert_eq!(
+            result,
+            RhoList::create_par(vec![
+                RhoNumber::create_par(1),
+                RhoString::create_par("two".into()),
+                RhoBoolean::create_par(true)
+            ])
+        );
+    }
+    #[test]
+    fn test_value_to_par_nested_array() {
+        let result = value_to_par(json!([[1, 2], [3, 4]])).unwrap();
+        assert_eq!(
+            result,
+            RhoList::create_par(vec![
+                RhoList::create_par(vec![RhoNumber::create_par(1), RhoNumber::create_par(2)]),
+                RhoList::create_par(vec![RhoNumber::create_par(3), RhoNumber::create_par(4)])
+            ])
+        );
+    }
+    #[test]
+    fn test_value_to_par_object() {
+        let result = value_to_par(json!({"key": "value", "num": 123})).unwrap();
+        assert_eq!(
+            result,
+            RhoMap::create_par(
+                vec![
+                    (
+                        RhoString::create_par("key".into()),
+                        RhoString::create_par("value".into())
+                    ),
+                    (
+                        RhoString::create_par("num".into()),
+                        RhoNumber::create_par(123)
+                    )
+                ]
+                .into_iter()
+                .collect()
+            )
+        );
+    }
+    #[test]
+    fn test_value_to_par_nested_object() {
+        let result = value_to_par(json!({
+            "outer": {
+                "inner": "value"
+            }
+        }))
+        .unwrap();
+        assert_eq!(
+            result,
+            RhoMap::create_par(
+                vec![(
+                    RhoString::create_par("outer".into()),
+                    RhoMap::create_par(
+                        vec![(
+                            RhoString::create_par("inner".into()),
+                            RhoString::create_par("value".into())
+                        )]
+                        .into_iter()
+                        .collect()
+                    )
+                )]
+                .into_iter()
+                .collect()
+            )
+        );
+    }
+
+    #[test]
+    fn test_value_to_par_complex_nested_structure() {
+        let result = value_to_par(json!({
+            "list": [1, 2, 3],
+            "nested": {
+                "bool": true,
+                "null": null
+            }
+        }))
+        .unwrap();
+
+        assert_eq!(
+            result,
+            RhoMap::create_par(
+                vec![
+                    (
+                        RhoString::create_par("list".into()),
+                        RhoList::create_par(vec![
+                            RhoNumber::create_par(1),
+                            RhoNumber::create_par(2),
+                            RhoNumber::create_par(3)
+                        ])
+                    ),
+                    (
+                        RhoString::create_par("nested".into()),
+                        RhoMap::create_par(
+                            vec![
+                                (
+                                    RhoString::create_par("bool".into()),
+                                    RhoBoolean::create_par(true)
+                                ),
+                                (RhoString::create_par("null".into()), RhoNil::create_par())
+                            ]
+                            .into_iter()
+                            .collect()
+                        )
+                    )
+                ]
+                .into_iter()
+                .collect()
+            )
+        );
+    }
+
+    #[test]
+    fn test_value_to_par_empty_array() {
+        let result = value_to_par(json!([])).unwrap();
+        assert_eq!(result, RhoList::create_par(vec![]));
+    }
+
+    #[test]
+    fn test_value_to_par_empty_object() {
+        let result = value_to_par(json!({})).unwrap();
+        assert_eq!(result, RhoMap::create_par(std::collections::HashMap::new()));
+    }
+
+    #[test]
+    fn test_value_to_par_negative_number() {
+        let result = value_to_par(json!(-42)).unwrap();
+        assert_eq!(result, RhoNumber::create_par(-42));
+    }
+
+    #[test]
+    fn test_value_to_par_zero() {
+        let result = value_to_par(json!(0)).unwrap();
+        assert_eq!(result, RhoNumber::create_par(0));
+    }
+
+    #[test]
+    fn test_value_to_par_false_boolean() {
+        let result = value_to_par(json!(false)).unwrap();
+        assert_eq!(result, RhoBoolean::create_par(false));
+    }
+
+    #[test]
+    fn test_value_to_par_empty_string() {
+        let result = value_to_par(json!("")).unwrap();
+        assert_eq!(result, RhoString::create_par("".into()));
+    }
+
+    #[test]
+    fn test_value_to_par_unicode_string() {
+        let result = value_to_par(json!("Hello, 世界! 🌍")).unwrap();
+        assert_eq!(result, RhoString::create_par("Hello, 世界! 🌍".into()));
+    }
+
+    /// Test that petta_execute times out after 10 seconds for long-running computations.
+    /// This uses a large fibonacci number that should exceed the timeout.
+    #[tokio::test]
+    async fn test_petta_execute_timeout() {
+        use std::env;
+        use std::path::PathBuf;
+
+        // Check if PeTTa is available
+        let petta_path = PathBuf::from(env::var("PETTA_PATH").unwrap_or("./PeTTa".into()));
+        let metta_module_path: PathBuf =
+            [petta_path, PathBuf::from("src/metta.pl")].iter().collect();
+
+        if !metta_module_path.exists() {
+            eprintln!("Skipping timeout test: PeTTa not available");
+            return;
+        }
+
+        // Fibonacci of a very large number should timeout (10 second limit)
+        // fib(10000000) will take much longer than 10 seconds
+        let metta_code = r#"
+            (= (fib-tr $n $a $b) (if (== $n 0) $a (fib-tr (- $n 1) $b (+ $a $b))))
+            (= (fib $n) (fib-tr $n 0 1))
+            !(fib 10000000)
+        "#;
+
+        let result = petta_execute(metta_code).await;
+
+        // Should fail with a timeout error
+        assert!(
+            result.is_err(),
+            "Large fibonacci computation should timeout"
+        );
+
+        let err = result.unwrap_err();
+        let err_msg = format!("{:?}", err);
+
+        // Error should mention timeout
+        assert!(
+            err_msg.contains("timed out") || err_msg.contains("timeout"),
+            "Error should be a timeout error, got: {}",
+            err_msg
+        );
+    }
+}
diff --git a/rholang/src/rust/interpreter/system_processes.rs b/rholang/src/rust/interpreter/system_processes.rs
index 6a676daee..74fdfec69 100644
--- a/rholang/src/rust/interpreter/system_processes.rs
+++ b/rholang/src/rust/interpreter/system_processes.rs
@@ -1,5 +1,5 @@
 use crate::rust::interpreter::chromadb_service::{
-    CollectionEntries, Metadata, SharedChromaDBService
+    CollectionEntries, Metadata, SharedChromaDBService,
 };
 use crate::rust::interpreter::rho_type::{Extractor, RhoList, RhoNil};
 
@@ -16,7 +16,7 @@ use super::rho_type::{
     RhoBoolean, RhoByteArray, RhoDeployId, RhoDeployerId, RhoName, RhoNumber, RhoString,
     RhoSysAuthToken, RhoUri,
 };
-use super::swi_prolog_service::petta_compile;
+use super::swi_prolog_service::petta_execute;
 use super::util::vault_address::VaultAddress;
 use crypto::rust::hash::blake2b256::Blake2b256;
 use crypto::rust::hash::keccak256::Keccak256;
@@ -217,7 +217,7 @@ impl FixedChannels {
         byte_name(36)
     }
 
-    pub fn swipl_compile_petta() -> Par {
+    pub fn swipl_execute_petta() -> Par {
         byte_name(37)
     }
 }
@@ -255,7 +255,7 @@ impl BodyRefs {
     pub const CHROMA_UPSERT_ENTRIES: i64 = 34;
     pub const CHROMA_QUERY: i64 = 35;
     pub const CHROMA_DELETE_DOCUMENTS: i64 = 36;
-    pub const SWIPL_COMPILE_PETTA: i64 = 37;
+    pub const SWIPL_EXECUTE_PETTA: i64 = 37;
 }
 
 pub fn non_deterministic_ops() -> HashSet<i64> {
@@ -267,6 +267,7 @@ pub fn non_deterministic_ops() -> HashSet<i64> {
         BodyRefs::OLLAMA_GENERATE,
         BodyRefs::OLLAMA_MODELS,
         BodyRefs::GRPC_TELL,
+        BodyRefs::SWIPL_EXECUTE_PETTA,
     ])
 }
 
@@ -1663,7 +1664,10 @@ impl SystemProcesses {
             return Ok(previous_output);
         }
 
-        let meta = self.chromadb_service.get_collection_meta(&collection_name).await?;
+        let meta = self
+            .chromadb_service
+            .get_collection_meta(&collection_name)
+            .await?;
         let result_par = match meta {
             None => RhoNil::create_par(),
             Some(inner) => inner.into(),
@@ -1735,7 +1739,8 @@ impl SystemProcesses {
             return Ok(previous_output);
         }
 
-        let res = self.chromadb_service
+        let res = self
+            .chromadb_service
             .query(
                 &collection_name,
                 doc_texts.iter().map(|s| s.as_ref()).collect(),
@@ -1789,21 +1794,54 @@ impl SystemProcesses {
 
     // SWIPL section begin
 
-    pub async fn swipl_compile_petta(
+    /// System process handler for `rho:petta:execute` URN.
+    ///
+    /// Executes MeTTa code through the PeTTa (SWI-Prolog) interpreter and returns results
+    /// to the calling Rholang contract. This is a non-deterministic operation - results are
+    /// cached during play execution and replayed from cache during replay for consensus safety.
+    ///
+    /// # URN Specification
+    ///
+    /// **URN:** `rho:petta:execute`
+    ///
+    /// **Arity:** 2 arguments
+    ///
+    /// **Arguments:**
+    /// 1. `metta_code: String` - MeTTa code to execute
+    /// 2. `ack: Channel` - Acknowledgment channel to receive result
+    ///
+    /// # Return Shape
+    ///
+    /// Sends a single `Par` on the acknowledgment channel containing the execution result.
+    /// The structure matches PeTTa's JSON output converted to Rholang types.
+    ///
+    /// # Error Conditions
+    ///
+    /// Returns `InterpreterError` for:
+    /// - **Illegal argument error**: Wrong number of arguments or incorrect types
+    /// - **PeTTa not found**: `$PETTA_PATH` points to invalid location
+    /// - **Timeout**: Execution exceeds 10 seconds
+    /// - **MeTTa syntax error**: Invalid MeTTa code
+    /// - **JSON parse error**: PeTTa output is not valid JSON
+    /// - **Number overflow**: JSON number doesn't fit in i64
+    ///
+    /// Errors are propagated to the Rholang contract and captured in the evaluation result's
+    /// error list.
+    pub async fn swipl_execute_petta(
         &self,
         contract_args: (Vec<ListParWithRandom>, bool, Vec<Par>),
     ) -> Result<Vec<Par>, InterpreterError> {
         let Some((produce, is_replay, previous_output, args)) =
             self.is_contract_call().unapply(contract_args)
         else {
-            return Err(illegal_argument_error("swipl_compile_petta"));
+            return Err(illegal_argument_error("swipl_execute_petta"));
         };
 
         let [metta_code, ack] = args.as_slice() else {
-            return Err(illegal_argument_error("swipl_compile_petta"));
+            return Err(illegal_argument_error("swipl_execute_petta"));
         };
         let Some(metta_code) = RhoString::unapply(metta_code) else {
-            return Err(illegal_argument_error("swipl_compile_petta"));
+            return Err(illegal_argument_error("swipl_execute_petta"));
         };
 
         // Common piece of code.
@@ -1812,12 +1850,10 @@ impl SystemProcesses {
             return Ok(previous_output);
         }
 
-        // Perform the compilation
-        let output = petta_compile(&metta_code)?;
+        // Perform the execution and wrap in vector
+        let output = petta_execute(&metta_code).await?;
+        let output = vec![output];
 
-        // Parse the output
-        let result_par = RhoString::create_par(output);
-        let output = vec![result_par];
         produce(&output, &ack).await?;
         Ok(output)
     }
diff --git a/rholang/src/rust/interpreter/test_utils/utils.rs b/rholang/src/rust/interpreter/test_utils/utils.rs
index a1977a77c..db5cc5cbd 100644
--- a/rholang/src/rust/interpreter/test_utils/utils.rs
+++ b/rholang/src/rust/interpreter/test_utils/utils.rs
@@ -5,9 +5,46 @@ use crate::rust::interpreter::compiler::normalize::VarSort;
 use crate::rust::interpreter::compiler::normalize::VarSort::{NameSort, ProcSort};
 use models::rhoapi::Par;
 use std::collections::HashMap;
+use std::env;
+use std::path::PathBuf;
+use std::process::Command;
 
 use rholang_parser::SourcePos;
 
+// Helper for skipping PeTTa tests if runtime pre-requisites are not met (or
+// panicking if tests are mandatory).
+pub fn should_skip_petta_test() -> bool {
+    let require = env::var_os("REQUIRE_PETTA_TESTS").is_some();
+
+    let petta_path = PathBuf::from(env::var("PETTA_PATH").unwrap_or("./PeTTa".into()));
+    let metta_module_path = petta_path.join("src/metta.pl");
+
+    let petta_missing = !metta_module_path.exists();
+    let swipl_missing = Command::new("swipl")
+        .arg("--version")
+        .output()
+        .map(|output| !output.status.success())
+        .unwrap_or(true);
+
+    let error_message: String;
+    match (petta_missing, swipl_missing) {
+        (false, false) => return false,
+        (true, _) => {
+            error_message = "PeTTa test prerequisite unmet: PeTTa is missing".into();
+        }
+        (_, true) => {
+            error_message = "PeTTa test prerequisite unmet: swipl is missing".into();
+        }
+    }
+
+    if require {
+        panic!("{error_message}");
+    } else {
+        eprintln!("Skipping test: {error_message}");
+        true
+    }
+}
+
 pub fn name_visit_inputs_and_env() -> (NameVisitInputs, HashMap<String, Par>) {
     let input: NameVisitInputs = NameVisitInputs {
         bound_map_chain: BoundMapChain::default(),
diff --git a/rholang/tests/PETTA_TESTS_SUMMARY.md b/rholang/tests/PETTA_TESTS_SUMMARY.md
new file mode 100644
index 000000000..2c65169d2
--- /dev/null
+++ b/rholang/tests/PETTA_TESTS_SUMMARY.md
@@ -0,0 +1,104 @@
+# PeTTa Tests Summary
+
+This document summarizes the test suite implemented for the PeTTa (MeTTa +
+SWI-Prolog) execution functionality in RNode.
+
+## Requirements
+
+For the PeTTa tests to run, the following requirements must be met:
+
+1. **The PeTTa installation must be available**.
+
+   See [DEVELOPER.md](../../DEVELOPER.md) for details on how to initialize this git
+   submodule.
+
+   The installation location must be specified in the `PETTA_PATH` environment
+   variable. If this variable is not set, the relative path `./PeTTa` will be used,
+   which may fail or not depending on how the tests are run. Therefore, setting this
+   variable is encouraged.
+
+2. **`swipl` must be available in the `PATH`**.
+
+   See [DEVELOPER.md](../../DEVELOPER.md) for details on how to install this
+   program.
+
+If these are not available, the tests will be skipped by default. If this behaviour
+is not desirable (e.g: all tests must be run as part of CI), then the environment
+variable `REQUIRE_PETTA_TESTS` must be set.
+
+## Test Coverage Overview
+
+The test suite consists of:
+1. Unit tests for `value_to_par` function
+2. Unit tests for `petta_execute` function  
+3. Integration tests with Rholang runtime
+4. Replay tests to verify non-deterministic operation handling
+
+## Test Files
+
+### 1. Unit Tests: `value_to_par` Function and `petta_execute`
+**Location:** `rholang/src/rust/interpreter/swi_prolog_service.rs` (lines 127-360)
+
+**Coverage:** 18 unit tests
+
+Tests JSON→Par conversion for all data types:
+- Basic types: `null`, `boolean`, `number`, `string`
+- Collections: `array`, `object`
+- Nested structures: nested arrays, nested objects.
+- **Timeout test:** Large fibonacci computation that exceeds 10-second timeout
+
+**Run:** `PETTA_PATH=/path/to/PeTTa cargo test --package rholang --lib swi_prolog_service::tests`
+
+### 2. Direct Execution Tests
+**Location:** `rholang/tests/swipl_petta_execution_spec.rs`
+
+**Coverage:** 6 tests
+
+Tests the `petta_execute` function directly:
+- `test_petta_execute_simple_swap` - Basic pattern matching
+- `test_petta_execute_fibonacci` - Recursive function execution
+- `test_petta_execute_simple_arithmetic` - Simple operations
+- `test_petta_execute_invalid_syntax` - Error handling
+- `test_petta_execute_empty_code` - Edge case handling
+- `test_petta_execute_timeout_large_fibonacci` - Timeout enforcement for long-running computations
+
+**Run:** `PETTA_PATH=/path/to/PeTTa cargo test --package rholang --test swipl_petta_execution_spec`
+
+### 3. Integration Tests with Rholang Runtime
+**Location:** `rholang/tests/swipl_petta_integration_spec.rs`
+
+**Coverage:** 6 tests
+
+Same tests as above, but using the Rholang runtime.
+
+**Run:** `PETTA_PATH=/path/to/PeTTa cargo test --package rholang --test swipl_petta_integration_spec`
+
+### 4. Replay Tests (Non-Deterministic Operation Verification)
+**Location:** `rholang/tests/swipl_petta_replay_spec.rs`
+
+**Coverage:** 5 tests
+
+Critical tests for consensus safety:
+- `test_petta_is_registered_as_non_deterministic` - Verifies `SWIPL_EXECUTE_PETTA` in `non_deterministic_ops()`
+- `test_petta_replay_consistency` - Basic replay with cached output
+- `test_petta_replay_with_multiple_calls` - Multiple PeTTa calls in one contract
+- `test_petta_replay_error_consistency` - Error cases are replayed correctly
+- `test_petta_replay_uses_cached_output` - Verifies replay doesn't re-execute PeTTa
+
+**Run:** `PETTA_PATH=/path/to/PeTTa cargo test --package rholang --test swipl_petta_replay_spec`
+
+## Running All Tests
+
+### With PeTTa Installed
+```bash
+# Set PeTTa path
+export PETTA_PATH=/path/to/PeTTa
+
+# Run all PeTTa tests
+cargo test --package rholang --test swipl_petta_execution_spec
+cargo test --package rholang --test swipl_petta_integration_spec  
+cargo test --package rholang --test swipl_petta_replay_spec
+
+# Run unit tests
+cargo test --package rholang --lib swi_prolog_service::tests
+```
diff --git a/rholang/tests/RUN_PETTA_TESTS.sh b/rholang/tests/RUN_PETTA_TESTS.sh
new file mode 100755
index 000000000..35e1c055f
--- /dev/null
+++ b/rholang/tests/RUN_PETTA_TESTS.sh
@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Script to run all PeTTa-related tests
+# Usage: ./RUN_PETTA_TESTS.sh
+
+set -e
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# Check if PETTA_PATH is set, otherwise use default
+if [ -z "$PETTA_PATH" ]; then
+    PETTA_PATH="$REPO_ROOT/PeTTa"
+    echo -e "${YELLOW}PETTA_PATH not set, using default: $PETTA_PATH${NC}"
+fi
+
+# Check if PeTTa exists
+if [ ! -f "$PETTA_PATH/src/metta.pl" ]; then
+    echo -e "${YELLOW}Warning: PeTTa not found at $PETTA_PATH/src/metta.pl${NC}"
+    echo "Tests will skip PeTTa-dependent operations"
+    echo ""
+fi
+
+export PETTA_PATH
+
+echo -e "${BLUE}=== Running PeTTa Test Suite ===${NC}"
+echo ""
+
+# Run unit tests
+echo -e "${GREEN}[1/4] Running unit tests for value_to_par...${NC}"
+cargo test --package rholang --lib swi_prolog_service::tests
+echo ""
+
+# Run direct execution tests
+echo -e "${GREEN}[2/4] Running direct PeTTa execution tests...${NC}"
+cargo test --package rholang --test swipl_petta_execution_spec -- --nocapture
+echo ""
+
+# Run integration tests
+echo -e "${GREEN}[3/4] Running Rholang integration tests...${NC}"
+cargo test --package rholang --test swipl_petta_integration_spec -- --nocapture
+echo ""
+
+# Run replay tests
+echo -e "${GREEN}[4/4] Running replay tests (non-deterministic operations)...${NC}"
+cargo test --package rholang --test swipl_petta_replay_spec -- --nocapture
+echo ""
+
+echo -e "${BLUE}=== All PeTTa tests completed successfully! ===${NC}"
diff --git a/rholang/tests/swipl_petta_execution_spec.rs b/rholang/tests/swipl_petta_execution_spec.rs
new file mode 100644
index 000000000..c01f008b0
--- /dev/null
+++ b/rholang/tests/swipl_petta_execution_spec.rs
@@ -0,0 +1,153 @@
+use prost::Message;
+use rholang::rust::interpreter::{
+    swi_prolog_service::petta_execute, test_utils::utils::should_skip_petta_test,
+};
+
+/// Tests for PeTTa execution service. This service is experimental.
+/// This API is not finalized. Specifically, the interface between Rholang and MeTTa
+/// is not complete. Here we test simple success and failure cases.
+///
+/// These tests require PeTTa to be installed. Set PETTA_PATH environment variable
+/// to point to the PeTTa installation directory.
+/// Example: PETTA_PATH=/path/to/PeTTa cargo test
+
+#[tokio::test]
+async fn test_petta_execute_simple_swap() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let metta_code = "(= (swap (Pair $x $y)) (Pair $y $x)) !(swap (Pair 1 3))";
+    let result = petta_execute(metta_code).await;
+
+    assert!(
+        result.is_ok(),
+        "PeTTa execution should succeed: {:?}",
+        result.err()
+    );
+    let par = result.unwrap();
+
+    // Verify we got a valid Par structure back
+    assert!(
+        !par.encode_to_vec().is_empty(),
+        "Par structure should not be empty"
+    );
+}
+
+#[tokio::test]
+async fn test_petta_execute_fibonacci() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let metta_code = r#"
+        (= (fib-tr $n $a $b) (if (== $n 0) $a (fib-tr (- $n 1) $b (+ $a $b))))
+        (= (fib $n) (fib-tr $n 0 1))
+        !(fib 10)
+    "#;
+    let result = petta_execute(metta_code).await;
+
+    assert!(
+        result.is_ok(),
+        "Fibonacci execution should succeed: {:?}",
+        result.err()
+    );
+    let par = result.unwrap();
+
+    // Verify we got a valid Par structure back (result should be 55)
+    assert!(
+        !par.encode_to_vec().is_empty(),
+        "Par structure should not be empty"
+    );
+}
+
+#[tokio::test]
+async fn test_petta_execute_simple_arithmetic() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let metta_code = "!(+ 1 2)";
+    let result = petta_execute(metta_code).await;
+
+    assert!(
+        result.is_ok(),
+        "Simple arithmetic should succeed: {:?}",
+        result.err()
+    );
+    let par = result.unwrap();
+    assert!(
+        !par.encode_to_vec().is_empty(),
+        "Par structure should not be empty"
+    );
+}
+
+#[tokio::test]
+async fn test_petta_execute_invalid_syntax() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    // This should fail due to invalid MeTTa syntax
+    let metta_code = "(= incomplete";
+    let result = petta_execute(metta_code).await;
+
+    // We expect this to either error or return an error result
+    // The exact behavior depends on PeTTa's error handling
+    if result.is_err() {
+        println!("Got expected error: {:?}", result.err());
+    } else {
+        println!(
+            "PeTTa handled invalid syntax without error: {:?}",
+            result.ok()
+        );
+    }
+}
+
+#[tokio::test]
+async fn test_petta_execute_empty_code() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let metta_code = "";
+    let result = petta_execute(metta_code).await;
+
+    // Empty code might succeed or fail depending on PeTTa behavior
+    println!("Empty code result: {:?}", result);
+}
+
+#[tokio::test]
+async fn test_petta_execute_timeout_large_fibonacci() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    // Fibonacci of a very large number should timeout (10 second limit)
+    // fib(10000000) will take much longer than 10 seconds
+    let metta_code = r#"
+        (= (fib-tr $n $a $b) (if (== $n 0) $a (fib-tr (- $n 1) $b (+ $a $b))))
+        (= (fib $n) (fib-tr $n 0 1))
+        !(fib 10000000)
+    "#;
+
+    let result = petta_execute(metta_code).await;
+
+    // Should fail with a timeout error
+    assert!(
+        result.is_err(),
+        "Large fibonacci computation should timeout after 10 seconds"
+    );
+
+    let err = result.unwrap_err();
+    let err_msg = format!("{:?}", err);
+
+    println!("Timeout error (expected): {}", err_msg);
+
+    // Error should mention timeout
+    assert!(
+        err_msg.contains("timed out") || err_msg.contains("timeout"),
+        "Error should be a timeout error, got: {}",
+        err_msg
+    );
+}
diff --git a/rholang/tests/swipl_petta_integration_spec.rs b/rholang/tests/swipl_petta_integration_spec.rs
new file mode 100644
index 000000000..17ab8f511
--- /dev/null
+++ b/rholang/tests/swipl_petta_integration_spec.rs
@@ -0,0 +1,194 @@
+use crypto::rust::hash::blake2b512_random::Blake2b512Random;
+use models::rhoapi::{BindPattern, ListParWithRandom, Par, TaggedContinuation};
+use rholang::rust::interpreter::{
+    accounting::costs::Cost,
+    external_services::ExternalServices,
+    interpreter::EvaluateResult,
+    rho_runtime::{RhoRuntime, RhoRuntimeImpl},
+    test_utils::{resources::create_runtimes_with_services, utils::should_skip_petta_test},
+};
+use rspace_plus_plus::rspace::history::history_repository::HistoryRepository;
+use rspace_plus_plus::rspace::shared::{
+    in_mem_store_manager::InMemoryStoreManager, key_value_store_manager::KeyValueStoreManager,
+};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+async fn evaluate_petta_term(term: &str) -> EvaluateResult {
+    let mut kvm = InMemoryStoreManager::new();
+    let store = kvm.r_space_stores().await.unwrap();
+
+    let (runtime, _, _): (
+        RhoRuntimeImpl,
+        RhoRuntimeImpl,
+        Arc<
+            Box<
+                dyn HistoryRepository<Par, BindPattern, ListParWithRandom, TaggedContinuation>
+                    + Send
+                    + Sync
+                    + 'static,
+            >,
+        >,
+    ) = create_runtimes_with_services(store, false, &mut Vec::new(), ExternalServices::noop())
+        .await;
+
+    let rand = Blake2b512Random::create_from_bytes(&[]);
+    let initial_phlo = Cost::create(i64::MAX, "test".to_string());
+
+    runtime
+        .evaluate(term, initial_phlo, HashMap::new(), rand)
+        .await
+        .expect("Evaluation failed")
+}
+
+#[tokio::test]
+async fn test_petta_rholang_integration_swap() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let term = r#"
+        new executePetta(`rho:petta:execute`), stdout(`rho:io:stdout`), retCh in {
+            executePetta!("(= (swap (Pair $x $y)) (Pair $y $x)) !(swap (Pair 1 3))", *retCh) |
+            for(@result <- retCh) {
+                stdout!(result)
+            }
+        }
+    "#;
+
+    let result = evaluate_petta_term(term).await;
+
+    assert!(
+        result.errors.is_empty(),
+        "PeTTa swap should execute without errors: {:?}",
+        result.errors
+    );
+}
+
+#[tokio::test]
+async fn test_petta_rholang_integration_fibonacci() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let term = r#"
+        new executePetta(`rho:petta:execute`), retCh in {
+            executePetta!("(= (fib-tr $n $a $b) (if (== $n 0) $a (fib-tr (- $n 1) $b (+ $a $b)))) (= (fib $n) (fib-tr $n 0 1)) !(fib 10)", *retCh)
+        }
+    "#;
+
+    let result = evaluate_petta_term(term).await;
+
+    assert!(
+        result.errors.is_empty(),
+        "PeTTa fibonacci should execute without errors: {:?}",
+        result.errors
+    );
+}
+
+#[tokio::test]
+async fn test_petta_rholang_integration_arithmetic() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let term = r#"
+        new executePetta(`rho:petta:execute`), retCh in {
+            executePetta!("!(+ 1 2)", *retCh) |
+            for(@result <- retCh) {
+                retCh!(result)
+            }
+        }
+    "#;
+
+    let result = evaluate_petta_term(term).await;
+
+    assert!(
+        result.errors.is_empty(),
+        "PeTTa arithmetic should execute without errors: {:?}",
+        result.errors
+    );
+}
+
+#[tokio::test]
+async fn test_petta_rholang_multiple_calls() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let term = r#"
+        new executePetta(`rho:petta:execute`), ret1, ret2 in {
+            executePetta!("!(+ 1 2)", *ret1) |
+            executePetta!("!(* 3 4)", *ret2) |
+            for(@r1 <- ret1; @r2 <- ret2) {
+                ret1!(r1) | ret2!(r2)
+            }
+        }
+    "#;
+
+    let result = evaluate_petta_term(term).await;
+
+    assert!(
+        result.errors.is_empty(),
+        "Multiple PeTTa calls should execute without errors: {:?}",
+        result.errors
+    );
+}
+
+#[tokio::test]
+async fn test_petta_rholang_error_handling() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    // Test with invalid MeTTa syntax
+    let term = r#"
+        new executePetta(`rho:petta:execute`), retCh in {
+            executePetta!("(= incomplete", *retCh)
+        }
+    "#;
+
+    let result = evaluate_petta_term(term).await;
+
+    // Should produce an error due to invalid syntax
+    assert!(
+        !result.errors.is_empty(),
+        "Invalid MeTTa syntax should produce errors"
+    );
+}
+
+#[tokio::test]
+async fn test_petta_rholang_timeout_large_computation() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    // Test that timeout is enforced through the full Rholang runtime
+    // This fibonacci computation should timeout after 10 seconds
+    let term = r#"
+        new executePetta(`rho:petta:execute`), retCh in {
+            executePetta!("(= (fib-tr $n $a $b) (if (== $n 0) $a (fib-tr (- $n 1) $b (+ $a $b)))) (= (fib $n) (fib-tr $n 0 1)) !(fib 10000000)", *retCh)
+        }
+    "#;
+
+    let result = evaluate_petta_term(term).await;
+
+    // Should have errors due to timeout
+    assert!(
+        !result.errors.is_empty(),
+        "Large fibonacci computation should timeout and produce errors: {:?}",
+        result.errors
+    );
+
+    // Check that at least one error mentions timeout
+    let has_timeout_error = result.errors.iter().any(|err| {
+        let err_str = format!("{:?}", err);
+        err_str.contains("timed out") || err_str.contains("timeout")
+    });
+
+    assert!(
+        has_timeout_error,
+        "At least one error should mention timeout, errors: {:?}",
+        result.errors
+    );
+}
diff --git a/rholang/tests/swipl_petta_replay_spec.rs b/rholang/tests/swipl_petta_replay_spec.rs
new file mode 100644
index 000000000..610824563
--- /dev/null
+++ b/rholang/tests/swipl_petta_replay_spec.rs
@@ -0,0 +1,273 @@
+use crypto::rust::hash::blake2b512_random::Blake2b512Random;
+use rholang::rust::interpreter::{
+    accounting::costs::Cost,
+    rho_runtime::RhoRuntime,
+    system_processes::{non_deterministic_ops, BodyRefs},
+    test_utils::{resources::create_runtimes, utils::should_skip_petta_test},
+};
+use rspace_plus_plus::rspace::shared::{
+    in_mem_store_manager::InMemoryStoreManager, key_value_store_manager::KeyValueStoreManager,
+};
+use std::collections::HashMap;
+
+#[test]
+fn test_petta_is_registered_as_non_deterministic() {
+    let non_det_ops = non_deterministic_ops();
+
+    assert!(
+        non_det_ops.contains(&BodyRefs::SWIPL_EXECUTE_PETTA),
+        "SWIPL_EXECUTE_PETTA should be marked as non-deterministic"
+    );
+}
+
+/// This test demonstrates that PeTTa execution can be replayed successfully.
+/// We verify that:
+/// 1. PeTTa is registered as non-deterministic (see above)
+/// 2. Event log captures the PeTTa execution output
+/// 3. Replay runtime can be rigged with the event log
+/// 4. Replay execution completes without errors using cached output
+#[tokio::test]
+async fn test_petta_replay_consistency() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let mut kvm = InMemoryStoreManager::new();
+    let store = kvm.r_space_stores().await.unwrap();
+
+    let (mut runtime, mut replay_runtime, _) = create_runtimes(store, false, &mut Vec::new()).await;
+
+    let term = r#"
+        new executePetta(`rho:petta:execute`), retCh in {
+            executePetta!("!(+ 1 2)", *retCh) |
+            for(@_ <- retCh) { Nil }
+        }
+    "#;
+
+    let rand = Blake2b512Random::create_from_bytes(&[]);
+    let initial_phlo = Cost::create(i64::MAX, "replay test".to_string());
+
+    // 1. Execute in play mode
+    let play_checkpoint = runtime.create_soft_checkpoint();
+    let play_result = runtime
+        .evaluate(term, initial_phlo.clone(), HashMap::new(), rand.clone())
+        .await
+        .expect("Play evaluation failed");
+
+    assert!(
+        play_result.errors.is_empty(),
+        "Play should succeed: {:?}",
+        play_result.errors
+    );
+
+    // 2. Capture event log from play execution
+    let event_log = runtime.take_event_log();
+
+    // Verify event log contains data (non-deterministic operation was captured)
+    assert!(
+        !event_log.is_empty(),
+        "Event log should contain captured PeTTa execution"
+    );
+
+    // 3. Rig replay runtime with event log
+    replay_runtime
+        .rig(event_log)
+        .expect("Rig failed - this means PeTTa is not properly registered as non-deterministic");
+
+    // 4. Execute same term in replay mode
+    let replay_checkpoint = replay_runtime.create_soft_checkpoint();
+    let replay_result = replay_runtime
+        .evaluate(term, initial_phlo.clone(), HashMap::new(), rand)
+        .await
+        .expect("Replay evaluation failed");
+
+    assert!(
+        replay_result.errors.is_empty(),
+        "Replay should succeed using cached output: {:?}",
+        replay_result.errors
+    );
+
+    println!("Play cost: {:?}", play_result.cost);
+    println!("Replay cost: {:?}", replay_result.cost);
+    println!("Replay successfully used cached PeTTa output");
+
+    // Cleanup checkpoints
+    runtime.revert_to_soft_checkpoint(play_checkpoint);
+    replay_runtime.revert_to_soft_checkpoint(replay_checkpoint);
+}
+
+#[tokio::test]
+async fn test_petta_replay_with_multiple_calls() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let mut kvm = InMemoryStoreManager::new();
+    let store = kvm.r_space_stores().await.unwrap();
+
+    let (mut runtime, mut replay_runtime, _) = create_runtimes(store, false, &mut Vec::new()).await;
+
+    let term = r#"
+        new executePetta(`rho:petta:execute`), ret1, ret2 in {
+            executePetta!("!(+ 1 2)", *ret1) |
+            executePetta!("!(* 3 4)", *ret2) |
+            for(@_ <- ret1; @_ <- ret2) { Nil }
+        }
+    "#;
+
+    let rand = Blake2b512Random::create_from_bytes(&[]);
+    let initial_phlo = Cost::create(i64::MAX, "replay test".to_string());
+
+    let play_checkpoint = runtime.create_soft_checkpoint();
+    let play_result = runtime
+        .evaluate(term, initial_phlo.clone(), HashMap::new(), rand.clone())
+        .await
+        .expect("Play evaluation failed");
+
+    assert!(
+        play_result.errors.is_empty(),
+        "Play should succeed: {:?}",
+        play_result.errors
+    );
+
+    let event_log = runtime.take_event_log();
+    assert!(
+        !event_log.is_empty(),
+        "Event log should capture multiple PeTTa calls"
+    );
+
+    replay_runtime.rig(event_log).expect("Rig failed");
+
+    let replay_checkpoint = replay_runtime.create_soft_checkpoint();
+    let replay_result = replay_runtime
+        .evaluate(term, initial_phlo.clone(), HashMap::new(), rand)
+        .await
+        .expect("Replay evaluation failed");
+
+    assert!(
+        replay_result.errors.is_empty(),
+        "Replay should succeed: {:?}",
+        replay_result.errors
+    );
+
+    println!("Multiple PeTTa calls - Play cost: {:?}", play_result.cost);
+    println!(
+        "Multiple PeTTa calls - Replay cost: {:?}",
+        replay_result.cost
+    );
+    println!("Replay successfully used cached output for multiple calls");
+
+    runtime.revert_to_soft_checkpoint(play_checkpoint);
+    replay_runtime.revert_to_soft_checkpoint(replay_checkpoint);
+}
+
+#[tokio::test]
+async fn test_petta_replay_error_consistency() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let mut kvm = InMemoryStoreManager::new();
+    let store = kvm.r_space_stores().await.unwrap();
+
+    let (mut runtime, mut replay_runtime, _) = create_runtimes(store, false, &mut Vec::new()).await;
+
+    let term = r#"
+        new executePetta(`rho:petta:execute`), retCh in {
+            executePetta!("(= incomplete", *retCh)
+        }
+    "#;
+
+    let rand = Blake2b512Random::create_from_bytes(&[]);
+    let initial_phlo = Cost::create(i64::MAX, "replay error test".to_string());
+
+    let play_checkpoint = runtime.create_soft_checkpoint();
+    let play_result = runtime
+        .evaluate(term, initial_phlo.clone(), HashMap::new(), rand.clone())
+        .await
+        .expect("Play evaluation completed");
+
+    assert!(
+        !play_result.errors.is_empty(),
+        "Play should have errors for invalid MeTTa code"
+    );
+
+    let event_log = runtime.take_event_log();
+    assert!(!event_log.is_empty(), "Event log should capture error case");
+
+    replay_runtime
+        .rig(event_log)
+        .expect("Rig should work even with errors");
+
+    let replay_checkpoint = replay_runtime.create_soft_checkpoint();
+    let replay_result = replay_runtime
+        .evaluate(term, initial_phlo.clone(), HashMap::new(), rand)
+        .await
+        .expect("Replay evaluation completed");
+
+    println!(
+        "Error case - Play cost: {:?}, errors: {}",
+        play_result.cost,
+        play_result.errors.len()
+    );
+    println!(
+        "Error case - Replay cost: {:?}, errors: {}",
+        replay_result.cost,
+        replay_result.errors.len()
+    );
+    println!("Replay successfully handled error case using cached output");
+
+    runtime.revert_to_soft_checkpoint(play_checkpoint);
+    replay_runtime.revert_to_soft_checkpoint(replay_checkpoint);
+}
+
+/// This test verifies that PeTTa replay uses cached output instead of re-executing.
+#[tokio::test]
+async fn test_petta_replay_uses_cached_output() {
+    if should_skip_petta_test() {
+        return;
+    }
+
+    let mut kvm = InMemoryStoreManager::new();
+    let store = kvm.r_space_stores().await.unwrap();
+
+    let (mut runtime, mut replay_runtime, _) = create_runtimes(store, false, &mut Vec::new()).await;
+
+    let term = r#"
+        new executePetta(`rho:petta:execute`), retCh in {
+            executePetta!("!(+ 1 2)", *retCh) |
+            for(@_ <- retCh) { Nil }
+        }
+    "#;
+
+    let rand = Blake2b512Random::create_from_bytes(&[]);
+    let initial_phlo = Cost::create(i64::MAX, "replay cache test".to_string());
+
+    let play_checkpoint = runtime.create_soft_checkpoint();
+    let play_result = runtime
+        .evaluate(term, initial_phlo.clone(), HashMap::new(), rand.clone())
+        .await
+        .expect("Play evaluation failed");
+
+    let event_log = runtime.take_event_log();
+
+    assert!(
+        !event_log.is_empty(),
+        "Event log should contain PeTTa execution data"
+    );
+
+    replay_runtime.rig(event_log).expect("Rig failed");
+
+    let replay_checkpoint = replay_runtime.create_soft_checkpoint();
+    let replay_result = replay_runtime
+        .evaluate(term, initial_phlo.clone(), HashMap::new(), rand)
+        .await
+        .expect("Replay evaluation failed");
+
+    println!("Cached output test - Play cost: {:?}", play_result.cost);
+    println!("Cached output test - Replay cost: {:?}", replay_result.cost);
+    println!("Replay successfully retrieved and used cached PeTTa output from event log");
+
+    runtime.revert_to_soft_checkpoint(play_checkpoint);
+    replay_runtime.revert_to_soft_checkpoint(replay_checkpoint);
+}