Process Termination Signal

SIGTERM (signal 15) is the default termination signal sent by the kill command. It is a catchable, blockable, and ignorable signal that politely requests a process to terminate.

• The process can install a termination handler to perform cleanup: closing database connections, flushing buffers, and persisting state.
• This is the preferred signal for controlled shutdown sequences in agentic systems.
• If the agent ignores SIGTERM, the orchestrator escalates to SIGKILL.
• Docker sends SIGTERM first with a default 10-second grace period before SIGKILL.
• Kubernetes follows the same pattern: SIGTERM → grace period → SIGKILL.

SIGKILL (signal 9) is the ultimate termination mechanism. It is uncatchable, unblockable, and cannot be ignored by any process.

• The kernel immediately terminates the process without allowing any cleanup code to execute.
• No termination handler runs; resources may be left in an inconsistent state.
• Essential for terminating runaway processes or agents stuck in infinite loops.
• Often used by orphan process reapers and watchdog timers when graceful shutdown fails.
• Risk: abrupt termination can corrupt data files, leave lock files, or orphan child processes.

SIGINT (signal 2) is generated when a user presses Ctrl+C in a terminal. It is catchable and typically triggers a graceful shutdown.

• Designed for interactive foreground processes rather than daemonized agents.
• Most language runtimes (Python, Node.js) translate SIGINT into a KeyboardInterrupt exception.
• In agentic systems, SIGINT can be used during human-in-the-loop override scenarios.
• The agent can catch SIGINT to perform a controlled shutdown sequence before exiting.
• Unlike SIGTERM, SIGINT carries the semantic meaning of direct human intervention.

SIGHUP (signal 1) was originally designed to notify a process that its controlling terminal had disconnected. In modern agentic architectures, it serves a dual purpose.

• Daemon processes commonly repurpose SIGHUP as a command to reload configuration files without restarting.
• When a terminal session ends unexpectedly, SIGHUP is broadcast to all child processes.
• Nginx and systemd services use SIGHUP for graceful configuration reloads.
• In agentic systems, SIGHUP can trigger a quiesce mode: finish current work, reload config, resume.
• nohup and tmux/screen protect processes from SIGHUP during session disconnection.

Processes can control which signals they receive through signal masking. A blocked signal remains pending until the process unblocks it.

• SIGKILL and SIGSTOP cannot be blocked—this is enforced by the kernel.
• Signal masks are critical for atomic operations: block signals during a critical section, then process them afterward.
• sigprocmask() and pthread_sigmask() are the POSIX APIs for manipulating signal masks.
• In agentic systems, masking SIGTERM during a state rollback prevents partial corruption.
• The signal queue holds exactly one instance of each pending signal; duplicates are lost.

When a parent process receives a termination signal, the kernel does not automatically propagate it to child processes. This creates orphan process risks.

• Orphan processes are automatically reparented to PID 1 (init/systemd).
• Process groups allow signals to be sent to an entire tree using killpg() or negative PID values.
• systemd uses cgroups to track and terminate all processes in a service unit.
• In containerized agentic systems, the container runtime (containerd, CRI-O) handles signal propagation.
• An orphan process reaper must be implemented to clean up child processes that survive parent termination.

A mechanism designed to completely and immediately shut down an autonomous agent or system, overriding all other processes to prevent unintended harm. Kill switches operate at a higher architectural level than individual process signals, often triggering cascading termination sequences across distributed components.

• Can be physical (hardware button) or digital (API endpoint)
• Typically bypasses normal shutdown hooks for speed
• Often paired with Dead Man's Switch for operator absence scenarios

A predefined, ordered set of operations an agent executes to safely persist its state, release resources, and disconnect from external systems before terminating. Unlike a raw SIGKILL, this sequence allows the agent to complete critical cleanup tasks.

• Triggered by SIGTERM rather than SIGKILL
• Includes flushing write-ahead logs and closing database connections
• Prevents orphan processes and resource leaks

A specific function or code block within an agent that is registered to execute automatically upon receiving a shutdown signal, ensuring critical cleanup tasks are performed. This is the programmatic counterpart to the operating system's signal delivery mechanism.

• Catches SIGTERM, SIGINT, and sometimes SIGHUP
• Responsible for graceful degradation initiation
• Must be idempotent to handle duplicate signal delivery safely

An automatic termination mechanism that issues a kill command to an agent if a single operation or an entire task does not complete within a predefined maximum duration. This prevents runaway processes from consuming resources indefinitely.

• Typically escalates from SIGTERM to SIGKILL after a grace period
• Common in Kubernetes pod lifecycle management
• Configured via terminationGracePeriodSeconds

A system component responsible for identifying and cleaning up child processes that were spawned by an agent but continue to run after the parent agent has been terminated. Without a reaper, these orphaned processes consume resources and may hold file locks.

• The init process (PID 1) typically adopts orphans on Unix systems
• Container runtimes use subreapers via prctl(PR_SET_CHILD_SUBREAPER)
• Prevents zombie process accumulation in process tables

A special message sent to an agent or process within a distributed system that instructs it to immediately terminate its own execution upon receipt. This pattern is common in actor-based concurrency models and message queue architectures.

• Used in Akka, Erlang/OTP, and Azure Service Bus
• Allows for self-termination without external signal delivery
• Often includes a reason code for post-mortem analysis