Watcher

The description states that Watcher is a local Windows desktop application built using .NET 8 and WinForms. It automates the lifecycle of handoffs between AI agents (specifically ChatGPT and Codex), aiming to remove repetitive human copy/paste tasks while ensuring policy compliance, provenance tracking, and rejection of stale or unauthorized content.

It uses GitHub as a mailbox exchange between ChatGPT and Codex, with an alternative browser scraping method when GitHub uploads are blocked by OpenAI safety checks. The system is described as having four architectural concerns: source, authorization, delivery, and audit.

The product includes:

• Detection of upstream task readiness.
• Wake-up of configured Director based on policy.
• Capture and validation of exact response messages.
• Binding instruction bytes to signed provenance, destination, expiry, and replay state.
• Delivery only after policy acceptance.
• Recording of human-readable activity and evidence trails.
• Rejection of stale, ambiguous, off-path, modified, replayed, or misdirected work.

It is presented as a local, inspectable, safe, and observable orchestration product, not a cloud-based service.

Note: The author emphasizes that this is a preview release, not a production-ready system. It does not bypass subscriptions, authentication, authorization, usage limits, safety systems, or product policies.

The description states that Watcher began as an attempt to remove the repetitive relay between ChatGPT and Codex in a flight combat simulator. Over time, it evolved into a broader solution for automated desktop-agent handoffs, emphasizing trustworthiness and human governance.

Key claims:

• It replaces tedious copy/paste workflows.
• It ensures policy visibility and evidence traceability.
• It prevents unauthorized or stale work from being delivered.
• It treats activity history, diagnostics, and human confirmation as product features rather than debug afterthoughts.

The author also notes that agent workflows need transaction security, not just message transport — the useful unit of trust is a complete, current, destination-bound transaction with inspectable provenance.

Inference: The positioning appears to be toward developers or users who want secure, policy-driven automation between AI tools, particularly in environments where safety and auditability are critical.

The description does not clearly identify a specific customer segment or ideal customer profile (ICP). It implies that Watcher targets users of AI agents, especially those working with ChatGPT and Codex, who seek to automate workflows while maintaining control over what gets executed.

It is described as a local Windows desktop application, suggesting it may appeal to:

• Developers working in Windows environments.
• Users managing complex AI workflows requiring strict governance.
• Teams or individuals needing secure automation without API keys or cloud dependencies.

However, there is no evidence of target personas, buyer roles, or customer interviews. The only indication of user context comes from the author’s own use case (flight combat simulator).

Not evidenced: No explicit ICP, buyer persona, or customer segment defined.

The description does not provide any information about a business model or pricing structure.

It states that Watcher is a preview release, and that it is not a production service. It also notes that:

• The supported demonstration uses synthetic fixtures and a non-actionable test sink.
• Experimental live adapters are unsupported and excluded from the judge path.
• No API keys, subscriptions, or external services are required for evaluation.

Not evidenced: No pricing, monetization strategy, or business model described.

The author reports that Watcher is built with:

• .NET 8
• WinForms
• Uses C#, PowerShell, Git, GitHub, and Codex

It implements a separation of concerns:

• Source
• Authorization
• Delivery
• Audit

Key technical features include:

• Authenticated message objects instead of text extraction.
• Validation of parentage, ancestry, current-path membership, envelope integrity, destination binding, signing identity, expiry, nonce uniqueness, and replay state.
• Use of GitHub as a mailbox exchange.
• Browser scraping fallback for cases where GitHub uploads are blocked.
• Support for profile-driven authorization and workflow UI.
• Synthetic fixtures and test sink for safe evaluation.

Inference: The architecture suggests a focus on security and auditability over scalability or ease-of-use in cloud environments.

The description states that Watcher is a preview release, not a production-ready system. It includes:

• A runnable Windows product (not just a protocol or proof of concept).
• 203/203 packaged Preview offline application checks passed.
• 17/17 command-cancellation subset included within those checks.
• 295/295 checks in a separate provenance and intake suite.
• Zero duplicate acceptances, unauthorized deliveries, or silent recoveries.

However:

• There is no evidence of revenue, customers, or traction beyond the author’s own testing.
• The product is described as a preview, not yet released for general use.
• It does not claim unattended live-production reliability for experimental adapters.

Not evidenced: No data on adoption, usage, or revenue.

The description does not mention any competitors. However, based on the stated functionality — automating AI agent handoffs with provenance and replay protection — Watcher could potentially compete with:

• Tools that automate workflows between AI agents.
• Platforms offering orchestration for AI systems.
• Local automation tools in Windows environments.

No direct competitor names or market positioning are provided.

Not evidenced: No competitive analysis, no mention of existing solutions.

• Preview-only status: The product is not yet production-ready and lacks API integrations or scalability features.
• Limited scope: It only supports local Windows applications and does not integrate with cloud services or multi-tenant deployments.
• No commercial traction: No evidence of revenue, customers, or adoption beyond the author’s own use case.
• Self-reported claims: All descriptions are self-reported and unverified — no third-party validation or external data.
• Experimental adapters excluded from judge path: This suggests that core functionality may not be fully tested in real-world scenarios.

Inference: The risk of misalignment between stated capabilities and actual performance is high due to lack of independent verification.

1. What specific use cases or workflows are you targeting with Watcher beyond the flight combat simulator?
2. Are there any plans to support cloud-based integrations or multi-tenant deployments?
3. How do you intend to scale beyond a single-user, local Windows application?
4. What is your roadmap for moving from preview to production-ready status?
5. Have you considered how this product might be integrated into larger enterprise AI workflows?
6. Is there any plan to open-source parts of the system or make it available via API?
7. What are the key assumptions behind the current design decisions (e.g., reliance on GitHub as mailbox)?
8. How do you plan to handle edge cases that were not covered in the synthetic test fixtures?