SPC Watchdog

What the company appears to be: SPC Watchdog is a self-reported autonomous quality engineering tool designed for manufacturing environments. It claims to detect process violations using deterministic statistics, investigate root causes with row-level evidence via an LLM agent, and improve its playbook only after human approval.

What changed: The project description shows a deliberate technical architecture built around three layers: WATCH (deterministic detection), INVESTIGATE (LLM-powered root cause analysis), and LEARN (human-in-the-loop learning). It uses a thin three-layer system with fixed-seed simulations, deterministic verification, and sandboxed agent execution.

The single most important open question: Does SPC Watchdog actually function as described in its self-reported architecture, or is this a conceptual prototype that has not yet been validated in real-world manufacturing settings?

Note: This analysis is based entirely on the self-reported project description provided by the author. No external verification, traction data, revenue figures, customer names, or third-party corroboration are available.

The description states that SPC Watchdog is a system composed of three distinct layers:

• WATCH: Uses Python and NumPy for deterministic statistical process control (SPC) detection. It emits AR(1) measurements over WebSocket using a fixed-seed SQLite factory.
• INVESTIGATE: Launches a headless codex exec run configured for GPT-5.6 Sol, operating in a sandboxed environment with no shell or file access. The agent retrieves evidence only through a registered MCP broker and returns structured reports with stable row citations.
• LEARN: Implements a transactional human-in-the-loop state machine where proposals are reviewed and approved by humans before becoming part of the playbook.

The system includes:

• A live chart that flips from green to red when an SPC signal is triggered.
• An activity feed showing investigator actions.
• Structured reports with citation verification counts.
• A replay mechanism labeled as deterministic.
• Scenario-based testing including two complete flows (Scenario 1 and Scenario 2).

Inference: The product appears to be a proof-of-concept or prototype built for a hackathon, not yet validated in production environments.

The description states that SPC Watchdog targets "manufacturing quality engineers responding to an out-of-control SPC signal." It positions itself as solving the gap between commodity SPC detection and autonomous, cited investigation that can learn from process failures without granting unilateral control to the agent.

Key claims:

• Detection uses deterministic statistics.
• Investigation is powered by an LLM but constrained with sandboxed access and citation verification.
• Playbook improvements require human approval.
• The system preserves quality engineer authority where consequences are highest.

Inference: The positioning emphasizes trust, auditability, and speed over automation. It does not claim to replace engineers but rather enhance their workflow.

The description states that the intended users are "manufacturing quality engineers responding to an out-of-control SPC signal."

It also mentions:

• A 2024 industry analysis estimating unproductive automotive downtime at $2.3 million per hour.
• The canonical scenario runs in under 41.7 seconds of investigator runtime.

Inference: The target customer is likely a specific subset of manufacturing environments where SPC signals are common and the cost of delay is high. However, no explicit segmentation or customer validation is provided.

No evidence of pricing, monetization strategy, or business model is present in the description.

Finding: Not evidenced.

The system uses:

• A three-layer architecture: WATCH (Python/NumPy), INVESTIGATE (GPT-5.6 Sol with MCP broker), LEARN (human-in-the-loop).
• Fixed-seed SQLite for deterministic simulations.
• WebSocket communication for real-time chart updates.
• Structured JSON event streams from the agent.
• Deterministic verification of citations via a host gate re-reading tables and rows.
• Transactional state machine for playbook updates.
• 64 pytest tests, exact replay sequences, CI pipelines, and schema-versioned fixtures.

Inference: The technical implementation suggests a strong focus on determinism, sandboxing, and auditability. It is not clear whether this is a working prototype or a conceptual design.

The description includes:

• Scenario-based testing with two complete product flows.
• A repository with 64 pytest tests, exact replay-sequence regressions, frontend type-check/build, clean-clone Ubuntu CI, and schema-versioned sanitized fixtures.
• The project was submitted to the OpenAI 2026 hackathon.

Finding: No evidence of revenue, customers, or adoption beyond the author’s own testing and submission to a hackathon. The maturity level appears to be early-stage prototype.

No mention of competitors or competitive landscape is present in the description.

Finding: Not evidenced.

• Unverified claims: All technical and functional claims are self-reported and unverified.
• Prototype vs. Product: The system appears to be a hackathon prototype, not yet validated in real-world manufacturing settings.
• No traction or revenue: No evidence of actual use cases, customers, or monetization.
• Limited scope: The description focuses only on two scenarios; no indication of broader applicability or scalability.
• Dependency on GPT-5.6 Sol: The system relies heavily on a specific LLM version that may not be available in production environments.

Inference: There is significant risk that the described functionality has not been tested outside of controlled conditions.

1. Has SPC Watchdog been tested in actual manufacturing environments?
2. What is the current status of the system beyond the hackathon prototype?
3. Are there any plans to integrate with existing SPC tools or ERP systems?
4. How does the system handle edge cases not covered in the two scenarios?
5. Is there a roadmap for scaling beyond the current sandboxed architecture?
6. What are the limitations of the deterministic verification process?