Skip to content
TheChatArchiveThe Chat Archive
Mistralmistral-medium-2505· Mistral AIHugging Face LMArena Human Preference 140K

You are trying to define a completely new type of interface for power users to interact…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-flash’s answer.
  1. User

    You are trying to define a completely new type of interface for power users to interact with LLMs and Agents, entirely keyboard driven and information dense, boil everything down to dead simple but highly versatile primitives that allow for something incredible to naturally emerge

  2. Mistral Assistant

    Creating a completely new, keyboard-driven, information-dense interface for power users to interact with LLMs and agents requires a focus on minimalism, versatility, and composability. The goal is to design a system where a few simple primitives can combine in powerful ways, enabling complex workflows without unnecessary friction. Here’s a conceptual framework for such an interface:


    Core Principles:

    1. Keyboard-Centric: Everything is accessible via keyboard shortcuts, with no reliance on mouse or touch.
    2. Information Density: Maximize the amount of useful information displayed at once, with minimal visual clutter.
    3. Composability: Primitives should combine naturally to form higher-level workflows.
    4. State Awareness: The interface should always reflect the current state and context, making it easy to understand what’s happening.
    5. Low Latency: Actions should feel instantaneous, with no unnecessary delays.

    Primitives:

    1. Contexts:

      • A "context" is a workspace or environment where interactions happen. It can contain prompts, agents, outputs, and other data.
      • Primitives:
        • Create Context (C-c): Start a new context.
        • Switch Context (C-s): Quickly switch between contexts.
        • Fork Context (C-f): Duplicate a context to experiment or branch workflows.
        • Merge Context (C-m): Combine two contexts (e.g., merge outputs or prompts).
    2. Prompts:

      • A "prompt" is a unit of input to the LLM or agent. It can be text, code, or structured data.
      • Primitives:
        • Insert Prompt (P-i): Insert a new prompt at the cursor.
        • Edit Prompt (P-e): Edit the current prompt.
        • Chain Prompts (P-c): Link prompts together (e.g., output of one becomes input to another).
        • Template Prompt (P-t): Save a prompt as a reusable template.
    3. Agents:

      • An "agent" is an autonomous or semi-autonomous entity that can perform tasks, make decisions, or interact with other systems.
      • Primitives:
        • Spawn Agent (A-s): Create a new agent with a given role or instruction.
        • Assign Task (A-a): Assign a task or prompt to an agent.
        • Monitor Agent (A-m): View the agent’s current state, outputs, or logs.
        • Kill Agent (A-k): Terminate an agent.
    4. Outputs:

      • "Outputs" are the results of prompts or agent actions. They can be text, structured data, or even other primitives.
      • Primitives:
        • Capture Output (O-c): Save an output to a buffer or file.
        • Pipe Output (O-p): Send an output to another prompt, agent, or external tool.
        • Diff Outputs (O-d): Compare two outputs (e.g., before/after edits).
        • Annotate Output (O-a): Add metadata or notes to an output.
    5. Buffers:

      • A "buffer" is a temporary or persistent storage for text, code, or data. Think of it like a scratchpad or clipboard.
      • Primitives:
        • Create Buffer (B-c): Create a new buffer.
        • Switch Buffer (B-s): Switch to another buffer.
        • Yank/Paste (B-y/B-p): Copy or paste between buffers.
        • Search Buffers (B-/): Search across all buffers.
    6. Macros:

      • A "macro" is a recorded sequence of actions that can be replayed or edited.
      • Primitives:
        • Record Macro (M-r): Start recording a macro.
        • Replay Macro (M-p): Replay a recorded macro.
        • Edit Macro (M-e): Edit a macro’s steps.
        • Chain Macros (M-c): Combine multiple macros into a workflow.
    7. Modes:

      • The interface can operate in different "modes" to change the behavior of keys or the focus of interaction.
      • Primitives:
        • Enter Mode (M-[mode]): Switch to a mode (e.g., M-p for prompt mode, M-a for agent mode).
        • Exit Mode (M-q): Return to the default mode.

    Example Workflow:

    1. C-c to create a new context.
    2. P-i to insert a prompt, then type your input.
    3. A-s to spawn an agent and assign it the prompt (A-a).
    4. O-c to capture the agent’s output to a buffer.
    5. P-i to insert another prompt, then O-p to pipe the captured output into it.
    6. M-r to record a macro of these steps, then M-p to replay it with new inputs.

    Visual Design:

    • Minimal UI: Use a terminal-like interface with a status bar showing current context, mode, and active agents.
    • Syntax Highlighting: Color-code prompts, outputs, and agents for quick visual parsing.
    • Split Views: Allow horizontal or vertical splits to view multiple contexts or buffers simultaneously.
    • Inline Previews: Show previews of outputs or agent states inline, without switching focus.

    Advanced Features:

    • Contextual Help: Press ? to see a cheat sheet of available commands in the current context.
    • Fuzzy Search: Use Ctrl-p to quickly search and select contexts, prompts, or agents.
    • Versioning: Automatically version contexts and outputs, allowing you to roll back or diff changes.
    • External Integration: Pipe outputs to external tools (e.g., curl, jq, or custom scripts) and capture their results.

    Why This Works:

    • Power Users: The keyboard-driven nature and composability cater to users who prefer efficiency and speed.
    • Information Density: By focusing on text and minimal visuals, more information can be displayed and manipulated at once.
    • Emergent Complexity: Simple primitives combine to form complex workflows, allowing users to build their own tools and processes.

    This design is inspired by tools like Vim, Emacs, and terminal multiplexers like tmux, but tailored specifically for LLM and agent interactions. The goal is to make the interface feel like an extension of the user’s thought process, rather than a barrier to it.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.