Skip to main content

The Workspace: Your Integrated Product Environment

The Masterminds platform is an Integrated Product Environment (IPE)—think of it as an IDE for Product Teams.

Just as engineers have VS Code to write, debug, and deploy software, Masterminds provides everything product teams need to research, ideate, design, deliver, and grow a product.

While the IPE interfaces with specialist SaaS tools like Figma (Design), Jira (Program Mgmt), and Amplitude (Metrics) via MCP, all product development intelligence lives inside the platform to be continually used and managed by agents.

The workspace is built on a Context-First Architecture, consisting of three synchronized "Intelligence Engines" that work together to maintain the state of your product.

The Bridge (Top Navigation)​

The "Bridge" is your command center for switching contexts.

  • Initiative Workspaces: Separate environments for entirely different product initiatives. Each initiative has its own isolated memory, team, and database of artifacts.
  • Context Switching: Move between different Chats (Phases/Workstreams) within the initiative.
    • Note: Currently, context is scoped to each specific chat. Shared Initiative Context (where agents share memory across chats) is [#SOON].

1. Left Panel: The Communication Hub (Directives)​

This is your direct line to the Intelligence Team. This is where you direct the workflow. You define the "What" and "Why"; the agents reason about the "How".

  • Chats as Phases: Each Chat represents a specific Product Development Phase executed by a specific Agent.
  • Flexible Workflows: You can have multiple chats in one initiative.
    • Example Workflow:
      1. Chat A (Tony): Design an Outcome-Driven Roadmap.
      2. Chat B (Teresa): Use that roadmap to discover a solution for "Feature X".
      3. Chat C (Jony): Design the UI for "Feature X".
      4. Chat D (Linus): Write the technical specs for "Feature X".
  • Instruction Mode: When you speak here, you are directing an autonomous agent to perform a task, not just asking a question.
  • AI Processing:
    • Thinking: You will see the AIThinkingTerminal while the agent processes your request.
    • Output: The agent delivers "Knowledge Pills" (Deliverables) and text responses.
    • Real-time Streaming: Token-by-token streaming of responses is [#SOON].

2. Center Panel: The Visualizer & Editor​

The Center Panel is where the actual work happens. It is the "Active State" of your product.

  • The Visualizer (Immersive Review): When an agent produces an artifact (e.g., a User Persona, a PRD, or a Code Snippet), it appears here immediately. This allows you to review work without cluttering the chat.
  • The Editor (Advanced Refinement): Click "Edit" to enter the IDE-grade editor.
    • Bi-Directional Sync: Changes you make in the Editor are instantly learned by the agent (committed to memory). You don't need to copy-paste back into the chat.
  • Point of Activation (POA): During onboarding, this panel visualizes your strategic roadmap.

3. Right Panel: Agent Context (The Brain)​

The Right Panel is the Persistent Memory of your project.

  • Deliverables: Every file, document, or snippet generated by the team is stored here.
  • Structure: Deliverables are organized by Phases → Personas → Roadmaps, mirroring the agent's logic.
  • External Knowledge: You can upload external documents (PDFs, Text) here. The agents ingest this data to "Fact-Gate" their outputs against your specific reality.

The Core Loop: How It Works​

The power of the IPE comes from the interaction between these panels:

  1. Directive (Left): You tell Steve: "Analyze these interview notes."
  2. Visualizer (Center): Steve processes the data and generates a Key Insights deliverable, which opens automatically.
  3. Context (Right): The deliverable is saved to the Agent Context.
  4. Editor (Center): You edit the document to add a nuance Steve missed.
  5. Iteration (Left): You tag Jony: "@Jony, use Steve's insights to draft a solution." Jony reads the updated context from the Right Panel and begins work.

This loop—Directive -> Visualization -> Memory -> Refinement—ensures that your product evolves intelligently, with zero context loss.