Topic: UX Design — Importing External Knowledge and Systems of Record
Participants: Product, Design, Engineering
Goal: Define a coherent user experience for bringing external information into Seed, from simple document imports to autonomous agent-driven integrations.

1. Context

Seed Hypermedia enables knowledge communities to collaboratively organize, connect, and evolve information.

However, most organizational knowledge already exists elsewhere: in documents, websites, databases, and enterprise software.

We need to make it easy to bring this information into Seed while preserving its meaning, structure, provenance, and relationships.

Our challenge is not simply to import files. It is to transform external information into persistent, interconnected, and collaborative knowledge objects.

We should support several levels of complexity:

Files: Import PDFs, Markdown, Word documents, and other formats.

Web: Import individual web pages, entire websites, or collections of linked pages.

Connectors: Connect to enterprise systems of record through APIs.

Agent Importers: Delegate the discovery, extraction, transformation, and organization of information to agents, potentially using external services such as Datalab.

The UX should make these capabilities accessible without exposing unnecessary technical complexity.

2. Key Concepts

2.1 Source

The external location from which information originates.

Examples:

A PDF on a user’s computer.

A public website.

A shared folder.

An enterprise database.

An external application accessed through an API.

Questions:

What constitutes a source?

Is a source a file, a URL, a service, or a collection?

Should Seed maintain a persistent reference to the original source?

How do users distinguish imported content from content created natively in Seed?

2.2 Connection

An authorized relationship between Seed and an external system.

A connection may provide access to information through an API, authentication mechanism, or external tool.

Examples include enterprise document repositories, CRM systems, and research databases.

Questions:

Are connections configured globally, per account, or per Space?

Who can create and manage connections?

Can multiple agents share the same connection?

How do we communicate access permissions and security boundaries?

How do users revoke a connection?

2.3 Importer

A mechanism that retrieves information from a source and transforms it into Seed objects.

Different importers may perform different operations:

Extract text and media.

Preserve document structure.

Identify metadata.

Detect relationships.

Convert content into Seed blocks.

Create documents and organize them into Spaces.

Questions:

Is an importer a tool, an agent, or a workflow?

Should users explicitly choose an importer?

Can different importers process the same source?

How do users understand what an importer will produce?

2.4 Agent Importer

An agent that orchestrates one or more tools to perform an import.

For example, an agent might:

Connect to a website.

Discover relevant pages.

Use Datalab to extract structured information from PDFs.

Identify documents and their relationships.

Propose an organization within Seed.

Create the corresponding Seed documents.

Unlike a conventional importer, an agent can make decisions, ask questions, and adapt its behavior.

Questions:

Is an agent importer a specialized agent or a regular Seed agent with import tools?

Does the user configure an agent or simply describe the desired outcome?

Can agents request clarification during an import?

Should agents operate autonomously after initial authorization?

Can users reuse an agent for future imports?

2.5 Import Job

A specific execution of an import process.

An import job may be instantaneous or run for hours, depending on its complexity.

Possible states:

Configured → Running → Needs Attention → Review → Completed

With additional states for paused, failed, or cancelled jobs.

Questions:

How do users track progress?

Can imports run in the background?

Can users pause, resume, or cancel an import?

How are errors and partial results presented?

Can an import be retried without duplicating content?

2.6 Imported Knowledge

The result of transforming external information into Seed’s document and object model.

Imported content may include:

Documents and blocks.

Metadata and attributes.

Links between documents.

References to original sources.

Media and attachments.

Relationships between entities.

Questions:

What should become a document, a block, or an attribute?

How much of the original structure should be preserved?

Can an importer propose an ontology or semantic relationships?

How do users inspect and correct imported information?

Who becomes the author of an imported document?

2.7 Provenance and Synchronization

Imported information should remain traceable to its origin.

Importing also raises the question of whether the resulting Seed objects represent a one-time copy or an ongoing relationship with the source.

Questions:

Should imports preserve the original source, timestamp, and version?

How do we distinguish original content from agent-generated interpretations?

What happens when the original source changes?

Can Seed synchronize updates without overwriting local modifications?

How do we handle deletions, conflicts, and permissions?

Can imported documents evolve independently of their source?

3. Main User Journeys

We should design around four representative journeys.

Journey A: Import a PDF

Scenario: A researcher wants to import a scientific paper.

Selects a PDF.

Seed processes the document.

The user previews the extracted content.

Seed creates a structured document.

The user can annotate, link, and collaborate.

Design challenge: Make a simple import almost effortless while allowing advanced extraction and structural preservation.

Journey B: Import a Website

Scenario: A knowledge organizer wants to import a collection of online publications.

Provides a URL.

Seed discovers available pages.

The user selects the scope.

Seed imports the selected content.

The documents become part of a Space.

Design challenge: How do we communicate scope, hierarchy, and relationships before importing hundreds of pages?

Journey C: Connect an Enterprise System

Scenario: An organization wants to bring information from its existing system of record into Seed.

Selects an external service.

Authenticates and grants permissions.

Chooses the relevant datasets or collections.

Defines how information should be mapped into Seed.

Starts the import.

Reviews the results.

Design challenge: How do we make enterprise integrations understandable without forcing users to understand APIs, schemas, and authentication details?

Journey D: Delegate an Import to an Agent

Scenario: A user wants to build a knowledge base from a large collection of documents.

The user tells an agent:

“Import all the environmental reports from this repository, organize them by topic, preserve their citations, and identify relationships between the projects.”

The agent:

Identifies the source and required tools.

Proposes an import plan.

Requests authorization.

Executes the import.

Reports progress and exceptions.

Presents the results for review.

Design challenge: How do we combine natural-language interaction with predictable, inspectable, and controllable operations?

4. Central UX Question: Chat or Dedicated Interface?

This is probably the most important design decision of the workshop.

Option A: Chat-Based Import

The user interacts with an agent through conversation.

Advantages

Natural interaction.

Flexible and adaptable.

Suitable for complex or ambiguous tasks.

Supports iterative refinement.

Limitations

Difficult to visualize large datasets.

Progress and state may become buried in conversation.

Configuration can become repetitive.

Harder to inspect hundreds of imported objects.

Option B: Dedicated Import Interface

A structured interface guides the user through source selection, configuration, execution, and review.

Advantages

Predictable workflows.

Clear progress and status.

Easier bulk operations.

Better visibility into imported objects.

Easier to manage recurring imports.

Limitations

Less flexible.

Requires designing many configuration options.

May become complex as capabilities expand.

Option C: Hybrid Interface

Working hypothesis: Use conversation for intent and structured interfaces for configuration, control, and inspection.

For example:

The user tells an agent:

“Import these 500 PDFs and organize them by project.”

The agent responds with a proposed plan.

Seed presents a structured interface containing:

Source and scope.

Extraction settings.

Destination Space.

Proposed document structure.

Estimated operations.

Permissions.

Execution controls.

The user approves the plan and monitors execution through an import dashboard.

The agent remains available to explain results, resolve exceptions, and modify the plan.

Questions for the workshop

Where should the user start: Library, Space, Agent, or a dedicated Import screen?

Should every import be represented as an agent conversation?

Can the same import workflow operate with or without an agent?

When should the interface switch from conversation to structured controls?

Should an import agent have its own workspace?

How do we expose progress, errors, and imported objects without cluttering the chat?

Can users return to an import days or weeks later?

5. Important Product Decisions

5.1 Import vs. Sync

We need to distinguish between:

Import: Create Seed objects from an external source.

Sync: Maintain a relationship between external information and Seed objects over time.

Questions:

Is synchronization a separate feature or an import configuration?

Which system is authoritative?

Do we support one-way and two-way synchronization?

What happens when a user edits imported content?

5.2 Copy vs. Reference

Not every external resource needs to be copied into Seed.

Sometimes maintaining a reference is sufficient.

Questions:

When should Seed copy content?

When should Seed link to external information?

Can users convert references into imported documents later?

How do we preserve attribution and licensing?

5.3 Transformation vs. Preservation

An importer may preserve the original document or reorganize it into a new structure.

Questions:

Should imported content remain faithful to its original presentation?

Can agents split one source document into multiple Seed documents?

Can several sources be consolidated into one document?

How do we distinguish source content from agent-generated content?

5.4 Permissions and Trust

External information may contain confidential or restricted content.

Questions:

Who is authorized to import information?

Where is the information processed?

Can external processing services receive confidential documents?

Are imported objects private by default?

How are source permissions translated into Seed capabilities?

5.5 Reusability

An import may be a one-time operation or a recurring organizational process.

Questions:

Can users save import configurations?

Can an agent importer be reused?

Can importers be shared between members of a knowledge community?

Should users be able to schedule recurring imports?

6. Proposed Conceptual Model

A possible model for discussion:

Source → Connection → Importer → Import Job → Seed Objects

An agent can orchestrate this process:

Agent → Tools → Import Jobs → Seed Objects

The distinction matters:

Source: Where the information exists.

Connection: How Seed accesses it.

Tool: What operations are available.

Importer: How external information is transformed.

Agent: Who or what coordinates the operations.

Import Job: A particular execution.

Seed Objects: The resulting knowledge.

Not every import requires every component.

For example, importing a local PDF might not require a persistent connection or an agent.

An enterprise integration might require all of them.

Workshop question: Is this the right conceptual model, or are we introducing unnecessary abstractions?

7. Workshop Activities

Suggested duration: 2 hours

Activity 1 — Align on the Mental Model (20 minutes)

Review the key concepts.

Ask participants to describe how they understand the relationship between sources, connections, tools, importers, agents, and jobs.

Output: Shared terminology and an initial conceptual model.

Activity 2 — Map User Journeys (30 minutes)

Divide into groups and map the four journeys:

PDF import.

Website import.

Enterprise connector.

Agent-driven import.

For each journey, identify:

User intention.

Required decisions.

System actions.

Feedback.

Expected result.

Output: Four user journey maps.

Activity 3 — Explore Interaction Models (30 minutes)

Sketch three alternatives:

Chat-first.

Dedicated import interface.

Hybrid interface.

Compare the approaches using the same scenario: importing a large collection of documents through an agent.

Output: Alternative UX concepts and their trade-offs.

Activity 4 — Define the Import Lifecycle (20 minutes)

Design how users:

Configure an import.

Preview results.

Authorize execution.

Monitor progress.

Resolve exceptions.

Inspect imported objects.

Repeat or synchronize the import.

Output: Initial import lifecycle and interaction requirements.

Activity 5 — Decisions and Next Steps (20 minutes)

Agree on:

The primary entry point for importing information.

The role of agents in the import experience.

The relationship between chat and structured UI.

The minimum viable import workflow.

The next prototype to build.

Output: Design decisions, open questions, and prototype assignments.

8. Expected Workshop Outcomes

By the end of the workshop, we should have:

A shared vocabulary for external sources, connections, tools, importers, agents, and jobs.

A common UX model covering simple imports and complex agent-driven workflows.

A clear direction for the relationship between chat and dedicated interfaces.

An initial import lifecycle from source selection to usable Seed objects.

A prioritized prototype that can be tested with real users.

9. Guiding Design Principle

Importing information into Seed should feel less like transferring files and more like extending a knowledge network.

Users should not have to understand extraction pipelines, APIs, or agent orchestration.

They should be able to express what information they need, understand what Seed proposes to do, retain control over the process, and immediately begin working with the resulting knowledge.

The ultimate objective is not merely to ingest information.

It is to make existing knowledge available for collaboration, interpretation, and continuous improvement.

My suggestion for the workshop

I would make one question the centerpiece of the session:

Is importing knowledge an operation performed by the user, or a task delegated to an agent?

This distinction has major consequences for Seed’s UX architecture.

Rather than designing a separate agent-import experience, I would explore whether an Import Job is a first-class Seed object that both humans and agents can create, inspect, and control.

That would allow Seed to offer a simple PDF import button, a sophisticated enterprise integration interface, and an agent conversation—all operating on the same underlying model.

It also fits Seed’s broader philosophy: agents and humans should operate on shared objects rather than inhabit separate applications.