PACT

The description states that PACT is a provider-neutral live coordination protocol for coding agents. It allows agents like Codex and Claude to:

• Declare their objective and expected semantic surfaces they will change;
• See active agents and discover overlapping or dependent work;
• Receive compact, relevant project context instead of another agent’s conversation;
• Publish proposed overlays, checkpoints, evidence, and required actions;
• Leave revision-pinned, verifiable handoffs that another agent can resume.

It is described as not storing Git history, but rather storing coordination state that exists before and between commits. Git remains the source of truth for code.

The product includes:

• A versioned JSON Schema and conformance fixtures;
• A dependency-free CLI and local hash-chained daemon;
• Deterministic semantic-surface overlap and typed producer/consumer handoffs;
• Speculative overlays, checkpoints, leases, resume/restart recovery;
• A provider-neutral JavaScript driver and six-tool MCP bridge;
• Shared agent-host lifecycle with thin Codex and Claude launchers;
• A Team HTTP service with isolated credentials and PostgreSQL persistence;
• Docker, Nginx, Terraform, and a live OCI deployment;
• PACT Bench, an experiment harness with immutable, graph-ready results.

Not evidenced No evidence of actual integration or usage by third-party agents beyond the authors’ own testing. No mention of real-world deployments, customer feedback, or production use cases.

The description states that PACT started from a simple question: “What would a collaboration protocol look like if it were designed for coding agents rather than adapted from human chat?”

It positions itself as:

• A live coordination layer;
• A provider-neutral system (though the authors note this must exist at the protocol and driver boundary, not in marketing copy);
• A solution to semantic collisions that occur when multiple agents work on overlapping parts of a codebase.

The claim has evolved from:

• Initial idea: “what if Git were adapted for agents?”
• To current form: a structured coordination protocol with typed dependencies, checkpoints, and verifiable handoffs.

Inference The evolution suggests an iterative refinement toward a more robust system, but the description does not provide evidence of prior versions or user feedback shaping this progression.

The description states that PACT is intended for coding agents, such as:

• Codex;
• Claude;
• And future runtimes.

It targets developers working in teams using AI-powered tools who are trying to coordinate changes across shared codebases without relying on Git alone or noisy chat histories.

There is no mention of end-users, enterprise customers, or specific personas beyond the agents themselves.

Not evidenced No evidence of target customer segmentation, user interviews, or adoption by any real users. No indication of whether the product is aimed at individual developers or teams within organizations.

The description does not contain any information about:

• Revenue streams;
• Pricing models;
• Monetization strategy;
• Subscription plans or licensing terms.

It also does not state whether PACT will be open-source, commercial, or offered as a service.

Not evidenced No business model or pricing evidence is provided. The project appears to be in early development and has no commercial traction.

The authors report building:

• A reference implementation including CLI, daemon, JSON schemas, MCP bridge, SDK, provider hosts, Team server, benchmark runner, tests, infrastructure, documentation, and public site;
• A PACT Bench experiment harness with immutable, graph-ready results;
• Use of Codex and GPT-5.6 in development;
• Tools built using JavaScript, React, Next.js, Node.js, Docker, Terraform, PostgreSQL, Oracle Cloud Infrastructure, Nginx, MCP, JSON Schema.

The system supports:

• Local mode for one repository and sibling Git worktrees;
• Team mode with shared coordination records stored in a PostgreSQL-backed service;
• Explicit CLI commands for managing Team lifecycle;
• Integration into provider hosts (planned).

Inference The technical stack and architecture suggest a developer-focused tool built using modern web and infrastructure technologies. However, no evidence of production deployment or scalability testing is provided.

The description reports:

• A preliminary counterbalanced pilot comparing Git-only baseline, passive shared ledger, and active PACT coordination;
• Across 12 valid trials, PACT integrated successfully in 3 of 4 trials;
• Git-only and passive ledger both failed in 0 of 4 each;
• PACT detected all four dependencies with no false alerts.

However:

• The denominator is small (only one scenario and four PACT trials);
• The authors note that even successful trials did not guarantee correct implementation by receiving agents;
• No evidence of real-world adoption or usage beyond internal experiments.

Not evidenced No data on customer acquisition, retention, usage metrics, or product-market fit. No mention of any revenue, paying customers, or user feedback loops.

The description does not provide any information about:

• Direct competitors;
• Indirect substitutes;
• Market positioning relative to existing tools for code collaboration or AI agent coordination.

It implies that current solutions (like Git-based workflows and chat history sharing) are inadequate for agent coordination, but no comparative analysis is given.

Not evidenced No competitive landscape or differentiation strategy is described. No evidence of prior art or market gaps addressed.

• Lack of real-world usage: The product has only been tested in controlled experiments and not integrated into actual workflows.
• Unclear commercial viability: No pricing, monetization, or revenue model is described.
• Limited team size (2 members): Suggests limited capacity to scale or build out a full product.
• Self-reported success metrics: Results from PACT Bench are preliminary and not validated externally.
• No customer feedback loop: No evidence of user testing or iteration based on external input.

Inference The project is in an early experimental phase, with no clear path to market traction or commercialization. The lack of external validation raises concerns about scalability and real-world utility.

1. What specific problems are you solving for coding agents that current tools like Git or chat logs do not address?
2. How many actual agents (not just test cases) have used PACT in practice, and what was their feedback?
3. Are there any plans to open-source PACT or offer it as a service? If so, how will you monetize it?
4. What are the key assumptions behind your benchmark results, and how do they generalize beyond this one scenario?
5. How do you plan to integrate PACT into existing AI agent platforms (e.g., Codex, Claude)?
6. What is your roadmap for moving from local mode to full Team mode integration with providers?