Graft AI

The description states that Graft AI is a local-first developer tool and Codex plugin. It claims to:

• Turn GUI-only bugs into permanent regression tests.
• Use GPT-5.6 Sol for semantic understanding and planning.
• Employ Codex Browser for live interaction with web applications.
• Generate deterministic Playwright tests via Codex.
• Use a separate read-only verifier to confirm results.
• Support both product regressions (application-level fixes) and interface drift (adapter-level fixes).
• Provide a workflow from bug report → reproduction → proof → test generation → fix → certification.

It also supports MCP tool integration through “Graft Connect,” allowing certified workflows to be invoked via natural language.

The system is built using technologies including:

• browser automation
• Bun, Chromium, Playwright
• Codex SDK, GPT-5.6 Sol
• Rust, TypeScript, Node.js
• SQLite for state management
• GitHub Actions and CI/CD pipelines

Inference The tool appears to be a hybrid system combining probabilistic AI interpretation with deterministic software engineering practices.

The author states that Graft AI addresses a gap in current agent capabilities:

“Coding agents have become excellent at reading repositories, writing patches, and running tests. But many important software bugs do not exist in the code alone—they appear only when someone interacts with the product users actually see.”

This positions Graft as a solution for agent interaction with non-code interfaces, particularly internal dashboards, vendor portals, and legacy web systems.

The core claim is:

“Give coding agents eyes on the software they ship—not just the code.”

It further claims to:

• Turn visual understanding into verified evidence
• Generate permanent regression tests
• Support CI coverage
• Enable reviewable Codex repairs

There’s no indication of prior positioning or evolution in the description.

Inference Graft AI is positioned as a developer infrastructure layer that makes agent interaction with GUIs more reliable and testable, especially for internal tools where code visibility is limited.

The author states:

“Much of the software they depend on still lives behind internal dashboards, vendor portals, and legacy web interfaces that were designed for humans rather than agents.”

This implies a target audience of:

• Platform teams
• Internal tool developers
• Companies adopting Codex who need to extend its reach beyond repositories into UIs

The example used is:

“Launchpad, a representative internal release console used by a platform team.”

There’s no mention of enterprise customers, SaaS buyers, or external users.

Inference The ICP likely includes internal engineering teams working with legacy systems, especially those using Codex and facing GUI-based bugs that are hard to reproduce or test automatically.

Not evidenced.

The description does not contain any information about:

• Revenue streams
• Pricing models
• Monetization strategy
• Customer acquisition plans
• Subscription tiers or usage-based pricing

Inference No business model is described. The tool appears to be a prototype or proof-of-concept submitted for a hackathon.

The description provides detailed technical architecture:

• Uses GPT-5.6 Sol for semantic judgment and planning.
• Employs Codex Browser for live interaction without reimplementing browser automation.
• Generates deterministic Playwright tests.
• Implements a read-only verifier to avoid trusting UI success messages.
• Uses SQLite for durable state management.
• Supports MCP tool registration and dynamic tool discovery.
• Includes local CLI, Console, GitHub Actions integration.
• Designed with sandboxed adapters, idempotency, and explicit approval before writes.

The system enforces:

• Repair boundaries (interface drift vs. product regression)
• Semantic intent over visual cues
• Provenance tracking (separating live interaction from deterministic execution)

Inference The tool is built with strong emphasis on trust, determinism, and separation of concerns, suggesting a mature engineering approach to agent reliability.

Not evidenced.

The description contains no data or signals indicating:

• Customer adoption
• Usage metrics
• Product-market fit
• Real-world testing
• Feedback from users or developers
• Revenue or funding status

It does state:

“We also dogfooded Graft on a real identity and resume issue found in Graft’s own Console.”

This suggests internal use but not external traction.

Inference No evidence of traction or maturity beyond the author's own development and testing.

Not evidenced.

The description does not mention:

• Competitors
• Market size
• Alternative tools
• Competitive advantages
• Prior art in agent-browser interaction or regression testing

Inference The competitive context is unknown. Graft AI appears to be a novel concept within the space of agent-driven UI interaction, but no comparison with existing tools is made.

1. Unverified claims: All statements are self-reported and unverified.
2. No traction or adoption: No evidence of real-world usage or customer feedback.
3. Unclear scalability: The tool is described as local-first and built for developer workflows; unclear if it scales beyond prototype use.
4. Dependency on proprietary models: Relies heavily on GPT-5.6 Sol, which may not be available to others.
5. Limited integration scope: Only mentions internal dashboards and legacy systems; no mention of broader enterprise or public web support.
6. Hackathon origin: Submitted to a hackathon, suggesting early-stage development.

Inference The tool is likely in an early prototype phase with high potential but low demonstrated viability or market readiness.

1. What is the current level of testing or validation done outside of the author’s own use?
2. How does Graft handle edge cases where the UI changes significantly between runs?
3. Are there any known limitations in terms of browser compatibility or web frameworks supported?
4. Has the tool been tested with real teams or organizations using it in production?
5. What is the roadmap for monetization or commercial deployment?
6. Can you provide examples of how the read-only verifier works in practice?
7. How does Graft distinguish between interface drift and actual product regression in complex scenarios?
8. Is there a plan to support more than one type of verification provider?