Website landing page

About Signal

Signal is a deep-agent workspace for product teams. It was inspired directly by Anthropic’s article, Product management on the AI exponential, especially the idea that product work is moving away from defining certainty upfront and toward accelerating discovery. That framing resonated with a problem we kept seeing: PMs already have context across many systems, but answering even basic cross-functional questions still requires too much manual work. Customer feedback lives in one tool, roadmap context in another, engineering execution in another, and code changes in yet another. Signal was built to act as the layer that connects those systems and turns them into structured, decision-ready analysis.

We built Signal as a deep agent rather than a simple chat UI. The goal was not only to let a user ask a question, but to let the system gather evidence across authenticated sources, reason over it, and produce a useful synthesis. The app has two main surfaces: Product Chat and Deep Analysis. Product Chat lets users ask questions against connected systems. Deep Analysis runs a multi-step research workflow and generates a decision brief. A major principle behind the project is that the agent should only use tools the user or workspace has actually connected. If the user has connected only Linear and GitHub, the agent should not invent access to anything else.

The architecture reflects that principle. Ghost is used as the app’s core database. It stores users, integrations, workspace-level connections, chat sessions, pipeline runs, and generated artifacts. Airbyte Agent Connectors power authenticated product-system access. Instead of Signal storing raw third-party credentials, Airbyte provisions and manages hosted connectors for tools like Linear, GitHub, Asana, Sentry, and Typeform. Macroscope is used as the engineering intelligence layer. It gives the app access to codebase, git history, PRs, releases, and delivery context, which means the deep agent can synthesize both product and engineering signals in the same workflow.

One of the biggest things we learned is that AI-native product design is really a systems problem. “Connected” does not automatically mean “usable at runtime.” A provider can be connected in the integrations page but still not be available in chat or deep analysis until its runtime path is explicitly wired. We also learned that trust depends on accurate tool gating. If the agent says it can use Linear, it actually has to use Linear. If it cannot, the system has to say so clearly and deterministically instead of bluffing.

The hardest challenges were integration correctness and orchestration. We migrated the app’s persistence layer from Supabase to Ghost, reworked product integrations around Airbyte, and added Macroscope as an async engineering source via webhooks. That forced us to build callback handling, workspace-scoped integration state, per-user runtime filtering, and long-running research flows rather than fake synchronous responses.

What we built is a practical interpretation of the article’s thesis: better PM systems are no longer documentation-first systems, but agent-first systems that shorten the loop between signal, research, and decision.