Strategic Canvas — Blue Ocean Analysis — gblock-party
Skill: /positioning (Step 2 of 4: Strategic Canvas) · Product: gblock-party · Date: 2026-06-02 · Mode: Alignment Review
Sources: research/competitive-analysis.md, research/icp.md, research/journey-map.md, research/positioning-jtbd.md
Methodology: Blue Ocean Strategy (Kim & Mauborgne) — Value Curve + Four Actions (ERRC) Framework
Competing Factors
These are the dimensions on which the AI coding agent orchestration market competes in 2026. Each factor is extracted from observed competitive behavior in research/competitive-analysis.md, validated against ICP pain points in research/icp.md.
| Factor | Description | Why It Matters to the ICP |
|---|---|---|
| Agent Breadth | Number of CLI agents supported (Claude Code, Codex, OpenCode, Aider, Gemini CLI, etc.) | The Agent Conductor uses 2–4 tools simultaneously. Vendor lock-in to a single agent is a deal-breaker. Emdash leads with 27; Multica with 10+. |
| Session Persistence | Agents survive laptop close, network drop, and device switch without state loss | #1 stated desire: “Close the laptop, pick up where I left off.” Journey Map Critical Moment #2. Only Cursor (vendor cloud) and Grass (Daytona cloud) offer this today. |
| Mobile Access & Approvals | Monitor agents and approve/reject risky actions from phone via native app or PWA with push notifications | SSH on phone is “universally painful.” 62% of Copilot Remote approvals happen from notification banners. Mobile is the conversion trigger vs. free DIY. |
| BYO-Client Flexibility | User chooses their own front-end tool; product provides backend infrastructure, not a locked UI | ICP deal-breaker: vendor lock-in. Front-end layer is commoditizing (5+ OSS tools). “BYO-client is a must-have.” |
| Managed Infrastructure | Turnkey server provisioning and maintenance — no DIY VPS sysadmin | Current state is a 10-step DIY process (provision VPS, install CLIs, configure tmux, set up Tailscale…). Solo devs want zero setup. |
| Setup Simplicity | Time from signup to first agent session running | 2026 PLG bar: value in under 60 seconds. Target: <5 minutes to first agent session. DIY takes 30–60 minutes. |
| Review & Verification UX | End-to-end review: visual code diffs + browser preview + product-side verification (browser use, computer use) — not just raw git diff in a terminal |
Review is the bottleneck, not agent speed. “I can only review so fast.” Verification spans both code correctness (diffs) and product behavior (browser preview, visual testing, running the app). Tools that only help with diffs miss half the review problem. [Owner note — deferred:] This factor signals a potential companion product within the gblock-party product line: a review-focused tool that helps users get through the review process efficiently, balancing speed and thoroughness (not just raw speed, which causes its own issues). To be explored separately from this strategic canvas. |
| Zero-Inbound Security | No public ports on the server — all connectivity via outbound tunnels (Tailscale, Cloudflare Tunnel) | Every VPS tutorial teaches this. ICP deal-breaker: “required public inbound ports.” Table stakes for the VPS workflow, but no competitor bundles it with managed orchestration. |
| Open Source / Trust Signal | Source code available for inspection; community can verify security and contribute | T3 Code’s MIT license cited as a strength. Users trust what they can inspect. GitHub stars signal credibility. OSS drives developer adoption. |
| Price Accessibility | Total monthly cost to the user, including compute and subscriptions | ICP analysis suggests the price ceiling is roughly $30/mo given that the primary alternative (tmux+VPS) is free. Credit-based pricing generates hostility (Intent: “afraid to ask questions”). Most competitors are free/BYOK. (Note: the $30/mo threshold is an analytical inference from ICP research, not a direct user quote or market data point. Will be validated during monetization/pricing work.) |
Gate: Competing Factors Accuracy
Are these 10 competing factors an accurate representation of how the AI agent orchestration market competes? Are any critical dimensions missing?
Value Curve Table
Competitors scored on each factor: High = industry-leading, Medium = at or near industry standard, Low = below standard or deliberately de-emphasized. Scores are based on observed evidence from research/competitive-analysis.md.
Competitors selected: the primary alternative (DIY tmux), the three closest direct competitors (Emdash, Nimbalyst, Multica), and two platform incumbents (Cursor, Copilot Remote) that define the high end. gblock-party is scored on its planned architecture.
| Factor | DIY (tmux+VPS) | Emdash | Nimbalyst | Multica | Cursor | Copilot Remote | gblock-party |
|---|---|---|---|---|---|---|---|
| Agent Breadth | High Unlimited — any CLI |
High 27 agents |
Low 2–4 agents |
High 10+ agents |
Low Own agent only |
Low Copilot only |
High Agent-agnostic (planned) |
| Session Persistence | Medium tmux survives SSH drop, not laptop sleep without VPS |
Low No headless mode |
Low Desktop-dependent |
Low Local daemon dies with host |
High Cloud agents (vendor cloud) |
Low Host machine must stay on |
High Managed always-on infra |
| Mobile Access & Approvals | Low SSH on phone |
Low No mobile |
Medium iOS only, desktop-dependent |
Low No mobile |
Low Web PWA only |
High GitHub Mobile, push notifications |
High PWA + push + risk-tiered approvals |
| BYO-Client Flexibility | High Full control — any tool |
Medium SSH remote, Electron UI |
Low Desktop app only |
Medium Docker self-hosted, own web UI |
Low Vendor UI locked |
Low Vendor UI locked |
High API-first, BYO any front-end |
| Managed Infrastructure | Low Full DIY (10-step process) |
Low Local machine |
Low Desktop machine |
Low Local Docker daemon |
High Vendor-managed cloud |
Low Local machine |
High Turnkey managed infra |
| Setup Simplicity | Low 30–60 min, 10 steps |
Medium Electron install + config |
Medium Desktop + iOS install |
Medium Docker Compose setup |
High Download & run |
High Built into Copilot |
High <5 min target |
| Review & Verification UX | Low Raw git diff, no preview |
Medium Diff viewer, no browser preview |
Medium Inline diff with accept/reject, no browser preview |
Low Terminal output only |
High Full IDE diff + browser preview |
Low Limited in mobile |
High BYO editor (VS Code remote, code-server) + Monaco web/mobile editor + browser preview + computer use verification |
| Zero-Inbound Security | Medium Manual Tailscale/CF setup |
Low N/A (local) |
Low N/A (local) |
Low No security model |
Low N/A (vendor cloud) |
Low N/A (vendor cloud) |
High Built-in Tailscale + CF Tunnel |
| Open Source / Trust | High All OSS tooling |
High Apache 2.0 |
High MIT/AGPL |
High Apache 2.0 |
Low Closed source |
Low Closed source |
Medium TBD — planned open-core |
| Price Accessibility | High Free (VPS cost only) |
High Free (BYOK) |
High Free |
High Free (BYOK) |
Low $20–200/mo |
Medium $10–39/mo (Copilot sub) |
Medium $9–29/mo planned |
Gate: Value Curve Scoring Accuracy
Are these competitor scores honest and evidence-based? Do any scores seem too generous or too harsh?
Value Curve Visualization
Bar height represents relative investment/performance: tall = High, medium = Medium, short = Low. gblock-party’s planned curve is shown alongside competitors to highlight divergence.
DIY (tmux+VPS)
Emdash
Nimbalyst
Multica
Cursor
Copilot Remote
gblock-party
Value Curve Observations
Cluster Zones (Red Ocean — everyone competes here)
- Agent Breadth: The OSS tools (Emdash, Multica, DIY) all cluster at High. This is a solved, commoditizing dimension. Competing on “we support the most agents” is not a durable differentiator — but being Low here (like Cursor, Copilot) is a deal-breaker for the ICP. Agent breadth is table stakes, not a positioning wedge.
- Open Source / Trust: Most direct competitors are open-source (Emdash Apache 2.0, Nimbalyst MIT/AGPL, Multica Apache 2.0). OSS is the community entry ticket, not a differentiator. Closed-source platforms (Cursor, Copilot) compensate with massive brand trust instead.
- Price Accessibility: Direct competitors cluster at High (free/BYOK). Charging anything means competing against free. Value must be visceral: “I literally could not do this before.”
Divergence Points (where gblock-party breaks from the pack)
Key insight: gblock-party’s value curve diverges most sharply on four factors: Session Persistence, Mobile Access, Managed Infrastructure, and Zero-Inbound Security. No direct competitor (Emdash, Nimbalyst, Multica) scores above Low on any of these four. Only platform incumbents (Cursor for persistence, Copilot Remote for mobile) partially match — but both are vendor-locked, single-agent solutions. Session Persistence is particularly notable: it’s a binary capability (sessions persist or they don’t), and bringing it as a standard to any BYO client is a Create move, not a Raise.
- Session Persistence: The sharpest divergence — and a binary one. Sessions either persist or they don’t. Every direct competitor is Low (sessions die with the host machine). Only Cursor offers persistence, but locked to their vendor cloud. gblock-party creates session persistence as a standard: any BYO client that connects inherits always-on sessions from the infrastructure layer. This is a Create move (new capability standard), not a Raise (graduated improvement).
- Managed Infrastructure: Direct competitors are all Low (local tools). Only Cursor offers managed infra, but requires their UI. gblock-party decouples managed infrastructure from the UI layer.
- Mobile Access & Approvals: Only Copilot Remote is High, but it’s single-agent, single-provider. Nimbalyst is Medium (iOS only, desktop-dependent). gblock-party plans multi-agent mobile with risk-tiered approval routing.
- Zero-Inbound Security: Only DIY is Medium (manual setup). No competitor bundles zero-inbound networking with managed agent orchestration.
Gaps (factors where no one invests fully — potential blue ocean)
Blue ocean territory: The combination of managed infrastructure + BYO-client + session persistence + mobile approvals + zero-inbound security is entirely unoccupied. Each factor is partially served by someone, but the intersection is empty. This is not a feature gap — it’s an architecture gap. No one has built the always-on, managed, BYO-client remote control plane.
- The “Managed BYO-Client” gap: DIY gives BYO-client but not managed. Cursor gives managed but not BYO-client. Nobody gives both. This is the architectural bet that defines gblock-party.
- The “Mobile + Multi-Agent” gap: Copilot Remote has mobile but single-agent. AgentsRoom has multi-agent mobile but is unproven and desktop-dependent. Nobody combines mobile push approvals with agent-agnostic multi-agent orchestration on persistent infrastructure.
- The “Security + Orchestration” gap: Zero-inbound is proven (every VPS guide teaches it) but no orchestration tool bundles it. The differentiation is the orchestration UX on top of zero-inbound, not zero-inbound itself.
Four Actions (ERRC) Framework
Strategic moves to create a new value curve. Each move is grounded in competitive and ICP evidence.
Eliminate
Factors the industry competes on out of habit that can be dropped entirely without losing the target customer.
Reduce
Over-served dimensions where the industry over-invests relative to customer value.
Raise
Under-served dimensions where customers want more than anyone provides.
Create
Entirely new dimensions of value that redefine competition.
Eliminate
| Factor | Rationale | Evidence | Risk |
|---|---|---|---|
| DIY sysadmin overhead | The industry assumes users will provision VPS, install CLIs, configure tmux, set up Tailscale. This is a 10-step process users tolerate because no managed alternative exists — not because they want it. gblock-party eliminates the entire setup chain by providing managed infrastructure. | ICP: “Zero setup, just connect.” Current State Journey documents 10-step DIY. VPS tutorial ecosystem exists precisely because setup is painful enough to need guides. | Users who enjoy infrastructure tinkering may see “managed” as loss of control. Mitigated by BYO-client: managed infra, your tools, your rules. |
Reduce
| Factor | Current Industry Level | Proposed Level | Rationale | Evidence |
|---|---|---|---|---|
| Price relative to platform incumbents | Low (free) to High ($200/mo) | Medium $9–29/mo flat rate |
Direct competitors are free. Platform incumbents charge $20–200/mo but bundle an IDE/agent. gblock-party reduces price below incumbents but above free — justified by managed infrastructure value that free tools cannot provide. | ICP analysis infers ~$30/mo ceiling given free alternatives. Intent credit pricing generates hostility. Cursor $20/mo is the reference anchor. DIY is free but costs 30–60 min setup. (Pricing threshold is analytical inference, not validated market data.) |
Raise
| Factor | Current Industry Level | Proposed Level | Rationale | Evidence |
|---|---|---|---|---|
| Mobile Access & Approvals | Low to Medium Single-agent, single-provider, or none |
High Multi-agent, risk-tiered, cross-provider |
Copilot Remote is the only High scorer but serves one agent from one provider. gblock-party raises mobile to agent-agnostic, multi-session, with intelligent risk-based approval routing (not just “approve everything from notification banners”). | 62% of Copilot approvals from banners. 93% auto-approve rate = security collapse. Gap 4: Smart Approval Routing. ICP: “Approve from my phone.” |
| Managed Infrastructure | Low Direct competitors: all local/self-managed |
High Turnkey, zero-sysadmin |
Every direct competitor requires the user to run infrastructure (local machine, Docker, VPS). Only platform incumbents offer managed infra but lock users to their UI. gblock-party raises managed infrastructure while preserving BYO-client. | ICP Current State: 10-step DIY. VPS providers creating AI agent landing pages validates demand. Competitive Analysis: “Nobody owns the solo developer always-on agent workstation space.” |
| Zero-Inbound Security | Medium DIY manual setup only |
High Built-in, zero-config |
Every VPS tutorial teaches zero-inbound via Tailscale. But it’s manual, error-prone, and adds to the 10-step DIY process. gblock-party raises zero-inbound from “DIY if you know how” to “built into the product, no ports to open.” | ICP deal-breaker: “required public inbound ports.” Competitive Analysis: “Zero-inbound is table stakes, not a differentiator” — the differentiator is bundling it with managed orchestration. |
| Review & Verification UX | Low to Medium Raw git diff (DIY), basic diff viewers (Emdash, Nimbalyst), full IDE (Cursor — vendor-locked) |
High BYO editor + optional Monaco + browser preview + computer use |
BYO-client architecture means review UX is composed by the user: VS Code remote, code-server, JetBrains Gateway, or any editor that connects to the managed infra. gblock-party can also offer a Monaco-based editor in a first-party PWA for client-agnostic users who want cross-device consistency. Browser preview and computer use verification run on the managed infrastructure. This matches Cursor’s review capability without vendor lock-in. Editor format (embedded vs. pure BYO) is an outstanding design decision. | Review is the bottleneck, not agent speed. BYO-client means review UX is not limited to what gblock-party ships. Cursor is High but locked to their editor. gblock-party raises review by providing the infrastructure that any editor can connect to, plus browser preview and computer use on managed infra. (Note: companion review product identified as a potential product-line opportunity — deferred.) |
Create
| Factor | Description | Customer Value | Evidence | Risk |
|---|---|---|---|---|
| Session Persistence as a Standard | Sessions either persist or they don’t — there are no layers. Today, most tools offer no persistence: sessions die with the host machine. Cursor offers persistence but only within its vendor cloud. gblock-party creates the standard that every agent session is persistent by default, regardless of which client connects to it. This is a binary capability gap, not a graduated dimension to raise. | Users stop managing session lifecycle entirely. “Close the laptop, pick up where I left off” becomes the default, not a feature to configure. Any BYO client that connects inherits always-on persistence from the infrastructure layer. | ICP #1 desire. Journey Map Critical Moment #2. JTBD: persistence is the functional anchor. Feature matrix: no competitor combines persistence + BYO-client. Cursor is the only High scorer, but persistence is locked to their vendor cloud — not a portable standard. | Persistence requires authoritative server-side session state. The infrastructure must be reliable enough that “always on” is credible. Downtime directly undermines the core promise. |
| Managed BYO-Client Infrastructure | A new architectural pattern: managed cloud infrastructure where the user’s own front-end tools connect via API. The product is the infrastructure layer; the UI is one of many possible clients. No competitor has decoupled managed infra from UI lock-in. | Users get the convenience of managed infrastructure (like Cursor cloud) with the freedom of BYO-client (like DIY). Best of both worlds: zero sysadmin, your tools. | Competitive Analysis: “The front-end agent orchestration UI is commoditizing. The durable value is the managed infrastructure underneath.” Gap 1: “Nobody owns the solo developer always-on agent workstation space.” Multica connectivity analysis: REST+WebSocket API feasibility proven. | Building API-first with third-party client support is harder than building a monolithic product. BYO-client adoption depends on third-party tool integration, which is mostly fork-only (except Multica). Mitigated: ship API-first for BYO-client connectivity as the primary path; first-party PWA dashboard provides monitoring, approvals, and mobile access. |
| Smart Approval Routing | Risk-classified permission routing that sends safe actions to auto-approve, medium-risk to notification banners for one-tap mobile approval, and high-risk to full mobile review with context. No tool does tiered risk classification for agent approvals. | Eliminates the 93% auto-approve security theater and the approval fatigue that created yoloAI. Users get security without friction: safe things happen automatically, dangerous things interrupt you on your phone with enough context to decide. | Competitive Analysis: 93% auto-approve rate. yoloAI exists to bypass friction. 62% of approvals from notification banners. Gap 4: “The UX of ‘approve safe things automatically, interrupt for dangerous ones, route to mobile’ doesn’t exist.” | Risk classification is hard to calibrate — too aggressive loses user trust, too conservative reproduces approval fatigue. Needs iterative tuning with real usage data. |
| Cross-Device Session Continuity | Not just “sessions persist” but true continuity: laptop → phone → different laptop, with each device picking up exactly where the last left off. No re-authentication, no lost state, no context gap. The aha is not single-device persistence but full control-plane portability. | “I started 5 agents, closed my laptop, had dinner, checked from my phone — 3 PRs were ready for review. Opened my other laptop the next morning and it felt like I’d never left.” | JTBD: aha moment quote extends to cross-device. Journey Map Journey 3: “Close Laptop, Keep Working.” No competitor offers seamless multi-device handoff for agent sessions. | Authentication and state sync across devices is complex. Session state must be authoritative on the server, not any client. Design complexity, not technical impossibility. |
| Agent Session API (Protocol) | A REST + WebSocket API for managing remote agent process lifecycles — start, stop, monitor, approve, diff-review. No standard exists for “UI to agent session backend” connectivity. MCP = model-to-tool. A2A = agent-to-agent. This would be the first UI-to-agent-session protocol. | The core interface BYO clients use to manage agent sessions on gblock-party infrastructure. Any front-end tool that speaks this API gets full session lifecycle control. | Competitive Analysis Protocol Gap: “No LSP-equivalent for how a frontend manages agent process lifecycles.” Multica is the only tool with a realistic integration path via REST + WebSocket. | Protocols succeed through adoption, not specification. Without ecosystem buy-in (from tools like Multica, Emdash), the API is gblock-party-specific infrastructure, not a protocol. Start as API, earn protocol status through adoption. |
Gate: ERRC Moves Accuracy
Are these four-actions moves accurate? Which feel wrong or need stronger evidence?
New Value Curve (After ERRC)
After applying the four actions, gblock-party’s target value curve diverges sharply from both the free OSS tools and the platform incumbents:
Target curve summary: gblock-party’s value curve is not a better version of any existing competitor. It creates a fundamentally new shape:
- High where direct competitors are Low: mobile access, managed infrastructure, zero-inbound security, review & verification UX
- High where platform incumbents are Low: agent breadth, BYO-client flexibility
- High matching platform incumbents but without lock-in: review & verification UX (BYO editor + infrastructure-provided browser preview vs. Cursor’s locked IDE)
- New factors no one measures: session persistence as a standard (binary — not a graduated raise), managed BYO-client infra, smart approval routing, cross-device continuity, agent session API
| Factor | Industry Average | gblock-party Target | Move |
|---|---|---|---|
| Agent Breadth | Mixed (High for OSS, Low for platforms) | High | Match (table stakes) |
| Session Persistence | Low (except Cursor vendor-locked) | High | Create (binary capability, not graduated) |
| Mobile Access & Approvals | Low to Medium | High | Raise |
| BYO-Client Flexibility | Mixed (High for DIY, Low for platforms) | High | Match (must-have) |
| Managed Infrastructure | Low (except Cursor) | High | Raise |
| Setup Simplicity | Medium | High | Raise (enabled by managed infra) |
| Review & Verification UX | Low to Medium | High | Raise (BYO editor + browser preview + computer use) |
| Zero-Inbound Security | Low to Medium | High | Raise |
| Open Source / Trust | High (for OSS tools) | Medium | Accept (open-core TBD) |
| Price Accessibility | Mixed (free to $200/mo) | Medium | Reduce (vs incumbents) |
| Managed BYO-Client Infra | N/A (doesn’t exist) | High | Create |
| Smart Approval Routing | N/A (doesn’t exist) | High | Create |
| Cross-Device Continuity | N/A (doesn’t exist) | High | Create |
| Agent Session API | N/A (doesn’t exist) | High | Create |
Strategic Implications
Category Impact
The strategic canvas suggests gblock-party does not fit cleanly into any existing category:
- Not an IDE / ADE: No code editor, no desktop app, no terminal multiplexer. Eliminates the entire surface that defines “AI Development Environment.”
- Not a CDE (Cloud Development Environment): Codespaces, Replit, and Kiro are cloud editors. gblock-party provides infrastructure, not an editor.
- Not an agent framework: LangChain, CrewAI, AutoGen orchestrate AI agents programmatically. gblock-party orchestrates CLI coding agents operationally.
- Not a mobile companion app: Nimbalyst and AgentsRoom are phone apps for desktop tools. gblock-party is infrastructure-first; the PWA is one client.
Diagnosis: gblock-party occupies a new category: “always-on agent workstation” — infrastructure that makes CLI coding agents always-on, device-independent, and mobile-controllable. Search term research (2026-06-04) resolved the label: “always-on” maps to user language, “agent” avoids GPU infra confusion, “workstation” is unclaimed and developer-native. Category-creation move (Play Bigger). The closest parallel is Coder (CDE control plane for enterprise), but for the solo developer segment with agent-native features.
Positioning Direction
The canvas supports infrastructure-first positioning:
“The always-on control plane for AI coding agents. Managed infrastructure. Your tools. Any device.”
This aligns with the JTBD positioning formula: “Your agents never stop. Monitor from any device. Approve from your phone. Use your own tools.”
Why infrastructure-first wins over UI-first:
- The front-end layer is commoditizing (5+ free OSS tools). Competing on UI is a red ocean.
- Managed infrastructure + BYO-client is the architectural bet that creates the blue ocean. [BYO-client connectivity needs validation]
- The product is built on Gap 1 (managed infra), sold on Gap 2 (session persistence), and experienced through Gap 3 (mobile monitoring & approval dashboard).
Competitive framing: DIY (tmux+VPS) is the primary alternative, not other tools. The pitch is “stop managing infrastructure, start shipping code” — not “our dashboard is better than Emdash.”
Risks & Watchpoints
- First-party encroachment: If Claude Code, Codex, or Copilot ships multi-agent mobile orchestration on persistent infrastructure, the blue ocean narrows. Currently single-agent, single-provider only. Monitor Q3-Q4 2026 announcements.
- Paying vs. free: The value curve requires charging ($9–29/mo) against free alternatives. The ERRC analysis shows the value is in dimensions free tools cannot provide (managed infra, persistence, mobile). But willingness-to-pay is unvalidated.
- Open-source expectations: gblock-party scores Medium on open source/trust vs. High for direct competitors. If the ICP demands OSS as a trust signal, an open-core model may be needed earlier than planned.
- BYO-client adoption: The “Create: Agent Session API” factor depends on third-party tool integration. Only Multica has a realistic integration path. Focus on API quality and documentation; validate connectivity with top 3–5 BYO-client targets. Dashboard PWA provides monitoring/approvals but is not the primary coding interface.
Gate: Strategic Direction
Does this canvas analysis support the right strategic direction for gblock-party?
Evidence Matrix
| Claim | Evidence Source | Evidence Type | Confidence |
|---|---|---|---|
| No competitor combines managed infra + BYO-client + multi-agent + mobile + zero-inbound | research/competitive-analysis.md — feature matrix of 27 competitors | Observed | High |
| Session persistence is the #1 user desire | research/icp.md — “Close the laptop, pick up where I left off” | Observed | High |
| Direct competitors (Emdash, Nimbalyst, Multica) score Low on persistence, mobile, managed infra | research/competitive-analysis.md — feature comparison, architecture analysis | Observed | High |
| Front-end layer is commoditizing (5+ OSS tools) | research/competitive-analysis.md — Frontend Commoditization section | Observed | High |
| DIY setup is a 10-step process; tutorials exist because it’s painful | research/icp.md Current State Journey; VPS tutorial ecosystem | Observed | High |
| 93% auto-approve rate = approval fatigue; yoloAI exists | research/competitive-analysis.md — User Sentiment Analysis | Observed | Medium |
| 62% of Copilot Remote approvals happen from notification banners | research/competitive-analysis.md — Copilot Remote section | Observed (competitor) | High |
| Multica is the only tool with a realistic BYO-client integration path (REST + WebSocket API) | research/competitive-analysis.md — Pluggable Frontend Model section | Observed (code analysis) | High |
| Smart approval routing (risk-tiered) doesn’t exist in any product | research/competitive-analysis.md — Gap 4 | Inferred | Medium |
| Cross-device session continuity (laptop → phone → different laptop) is novel | research/positioning-jtbd.md — aha moment; research/journey-map.md Journey 3 | Inferred | Medium |
| UI-to-agent-session-backend protocol gap exists (no MCP/A2A/ACP equivalent) | research/competitive-analysis.md — Protocol Gap section | Observed | High |
| gblock-party’s target value curve creates a fundamentally new shape vs. existing competitors | This analysis — ERRC synthesis across all sources | Inferred (synthesis) | Medium |
| Category is “always-on agent workstation” — not IDE, not CDE, not agent framework | This analysis — category impact assessment; search term research (2026-06-04) | Research-backed | Medium-High |
| Willingness to pay $9–29/mo for orchestration above free alternatives | research/icp.md — budget signals, pricing sensitivity | Hypothesized | Low |
Gate: Research Completeness
Is the evidence sufficient for the strategic canvas recommendations? Which claims need more support? Could missing context change the recommendation?
Confidence & Assumption Register
| Element | Confidence | Evidence Source | What Would Change It |
|---|---|---|---|
| 10 competing factors capture the market accurately | High | Extracted from 27-competitor analysis with feature matrix | Discovery of a major competing dimension not represented (e.g., AI model quality, code generation accuracy) |
| Competitor scores are honest and evidence-based | High | Feature-by-feature analysis from competitive-analysis.md | Product updates changing a competitor’s capability (e.g., Emdash ships mobile) |
| The four divergence factors (persistence, mobile, managed infra, zero-inbound) are the correct strategic axes | High | Cross-validated: ICP pain map, competitive gaps, JTBD functional dimensions | User interviews showing different priorities; a competitor closing all four gaps |
| Eliminate moves (DIY sysadmin, terminal monitoring) won’t lose the target customer | Medium | ICP desires “zero setup”; Pain Map rates tmux monitoring as Critical pain | User testing showing power users refuse products without terminal-first access |
| Create factors (managed BYO-client, smart approval, cross-device, session API) are genuinely novel | Medium | 27-competitor survey found none offering these; protocol gap analysis | Discovery of a product that already offers managed BYO-client infrastructure |
| Category is a new subcategory, not an existing one | Medium | This canvas analysis; no existing category fits the value curve shape | Market analyst classifying gblock-party into an existing category that works |
| Users will pay $9–29/mo for managed orchestration vs. free DIY | Low | ICP budget signals only; no willingness-to-pay data | Price-point testing and actual conversion data |
| Open-core at Medium trust is acceptable to the ICP | Low | Inferred; most direct competitors are fully OSS | User feedback showing OSS is a purchase prerequisite |
Proposed File Changes
Upon approval, the following files will be created or updated:
- CREATE:
research/positioning-strategic-canvas.md— Full strategic canvas research artifact with competing factors, value curve table, ERRC grid, strategic implications, evidence matrix, and confidence register. - UPDATE:
tasks/todo.md— Mark Step 2 (strategic canvas) as complete. - UPDATE:
tasks/history.md— Record strategic canvas completion.
Gate: Proposed File Changes
Approve the proposed file changes?
Compile Review
Use section feedback controls above to flag individual concerns, or compile final answers below when all gates are answered.