diff --git a/components/settings/RoleBuilderTab.tsx b/components/settings/RoleBuilderTab.tsx
new file mode 100644
index 0000000..c315b92
--- /dev/null
+++ b/components/settings/RoleBuilderTab.tsx
@@ -0,0 +1,732 @@
+import React, { useState, useEffect } from 'react';
+import { 
+  WorkflowSchemaProfile, 
+  ConfigurableRole, 
+  RoleTypeSchema, 
+  RoleFieldSchema 
+} from '../../types/roleSchema';
+import { RoleSchemaService } from '../../services/roleSchemaService';
+
+interface RoleBuilderTabProps {
+  disabled?: boolean;
+}
+
+const RoleBuilderTab: React.FC<RoleBuilderTabProps> = ({ disabled = false }) => {
+  const [profiles, setProfiles] = useState<WorkflowSchemaProfile[]>([]);
+  const [selectedProfile, setSelectedProfile] = useState<WorkflowSchemaProfile | null>(null);
+  const [editingProfile, setEditingProfile] = useState<WorkflowSchemaProfile | null>(null);
+  const [editingRole, setEditingRole] = useState<ConfigurableRole | null>(null);
+  const [roleTypeSchemas] = useState<RoleTypeSchema[]>(() => 
+    RoleSchemaService.getInstance().getRoleTypeSchemas()
+  );
+  const [showRoleModal, setShowRoleModal] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [showImportModal, setShowImportModal] = useState(false);
+  const [importData, setImportData] = useState('');
+
+  const service = RoleSchemaService.getInstance();
+
+  useEffect(() => {
+    loadProfiles();
+  }, []);
+
+  const loadProfiles = () => {
+    try {
+      const loadedProfiles = service.getAllProfiles();
+      setProfiles(loadedProfiles);
+      if (!selectedProfile && loadedProfiles.length > 0) {
+        setSelectedProfile(loadedProfiles[0]);
+      }
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to load profiles');
+    }
+  };
+
+  const handleCreateProfile = () => {
+    const newProfile: WorkflowSchemaProfile = {
+      id: `profile-${Date.now()}`,
+      name: 'New Workflow Profile',
+      description: 'Custom workflow profile',
+      version: '1.0.0',
+      roles: [],
+      executionOrder: [],
+      globalSettings: {
+        maxTotalIterations: 15,
+        timeoutMinutes: 30,
+        allowParallelReviews: false
+      },
+      metadata: {
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        author: 'User',
+        tags: []
+      }
+    };
+    setEditingProfile(newProfile);
+  };
+
+  const handleEditProfile = (profile: WorkflowSchemaProfile) => {
+    setEditingProfile({ ...profile });
+  };
+
+  const handleSaveProfile = () => {
+    if (!editingProfile) return;
+
+    try {
+      if (profiles.some(p => p.id === editingProfile.id && p !== selectedProfile)) {
+        service.addProfile(editingProfile);
+      } else {
+        service.updateProfile(editingProfile.id, editingProfile);
+      }
+      loadProfiles();
+      setSelectedProfile(editingProfile);
+      setEditingProfile(null);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to save profile');
+    }
+  };
+
+  const handleDeleteProfile = (profileId: string) => {
+    try {
+      service.deleteProfile(profileId);
+      loadProfiles();
+      if (selectedProfile?.id === profileId) {
+        setSelectedProfile(profiles.find(p => p.id !== profileId) || null);
+      }
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to delete profile');
+    }
+  };
+
+  const handleAddRole = (typeId: string) => {
+    if (!editingProfile) return;
+
+    const schema = roleTypeSchemas.find(s => s.id === typeId);
+    if (!schema) return;
+
+    const newRole: ConfigurableRole = {
+      id: `role-${Date.now()}`,
+      typeId,
+      name: schema.name,
+      description: schema.description,
+      configuration: getDefaultConfiguration(schema),
+      executionSettings: {
+        enabled: true,
+        ...(schema.defaultSettings || {}),
+        maxLoops: schema.category === 'reviewer' ? 2 : undefined
+      }
+    };
+
+    setEditingRole(newRole);
+    setShowRoleModal(true);
+  };
+
+  const handleEditRole = (role: ConfigurableRole) => {
+    setEditingRole({ ...role });
+    setShowRoleModal(true);
+  };
+
+  const handleSaveRole = () => {
+    if (!editingProfile || !editingRole) return;
+
+    try {
+      const validation = service.validateRoleConfiguration(editingRole.typeId, editingRole.configuration);
+      if (!validation.isValid) {
+        setError(`Role configuration errors: ${validation.errors.join(', ')}`);
+        return;
+      }
+
+      const existingIndex = editingProfile.roles.findIndex(r => r.id === editingRole.id);
+      if (existingIndex >= 0) {
+        editingProfile.roles[existingIndex] = editingRole;
+      } else {
+        editingProfile.roles.push(editingRole);
+        editingProfile.executionOrder.push(editingRole.id);
+      }
+
+      setEditingProfile({ ...editingProfile });
+      setShowRoleModal(false);
+      setEditingRole(null);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to save role');
+    }
+  };
+
+  const handleRemoveRole = (roleId: string) => {
+    if (!editingProfile) return;
+
+    setEditingProfile({
+      ...editingProfile,
+      roles: editingProfile.roles.filter(r => r.id !== roleId),
+      executionOrder: editingProfile.executionOrder.filter(id => id !== roleId)
+    });
+  };
+
+  const getDefaultConfiguration = (schema: RoleTypeSchema): Record<string, any> => {
+    const config: Record<string, any> = {};
+    schema.fields.forEach(field => {
+      if (field.defaultValue !== undefined) {
+        config[field.id] = field.defaultValue;
+      }
+    });
+    return config;
+  };
+
+  const renderRoleField = (field: RoleFieldSchema, value: any, onChange: (value: any) => void) => {
+    const fieldId = `field-${field.id}`;
+
+    switch (field.type) {
+      case 'text':
+        return (
+          <input
+            id={fieldId}
+            type="text"
+            value={value || ''}
+            onChange={(e) => onChange(e.target.value)}
+            placeholder={field.placeholder}
+            className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary text-sm"
+            disabled={disabled}
+          />
+        );
+
+      case 'textarea':
+        return (
+          <textarea
+            id={fieldId}
+            value={value || ''}
+            onChange={(e) => onChange(e.target.value)}
+            placeholder={field.placeholder}
+            rows={3}
+            className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary text-sm"
+            disabled={disabled}
+          />
+        );
+
+      case 'number':
+        return (
+          <input
+            id={fieldId}
+            type="number"
+            value={value || ''}
+            onChange={(e) => onChange(parseInt(e.target.value) || 0)}
+            min={field.min}
+            max={field.max}
+            className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary text-sm"
+            disabled={disabled}
+          />
+        );
+
+      case 'boolean':
+        return (
+          <label className="flex items-center">
+            <input
+              id={fieldId}
+              type="checkbox"
+              checked={value || false}
+              onChange={(e) => onChange(e.target.checked)}
+              className="mr-2"
+              disabled={disabled}
+            />
+            <span className="text-sm text-theme-secondary">Enable this option</span>
+          </label>
+        );
+
+      case 'select':
+        return (
+          <select
+            id={fieldId}
+            value={value || ''}
+            onChange={(e) => onChange(e.target.value)}
+            className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary text-sm"
+            disabled={disabled}
+          >
+            <option value="">Select an option...</option>
+            {field.options?.map((option) => (
+              <option key={option.value} value={option.value}>
+                {option.label}
+              </option>
+            ))}
+          </select>
+        );
+
+      case 'multiselect':
+        return (
+          <div className="space-y-1">
+            {field.options?.map((option) => (
+              <label key={option.value} className="flex items-center">
+                <input
+                  type="checkbox"
+                  checked={(value || []).includes(option.value)}
+                  onChange={(e) => {
+                    const currentValues = value || [];
+                    if (e.target.checked) {
+                      onChange([...currentValues, option.value]);
+                    } else {
+                      onChange(currentValues.filter((v: string) => v !== option.value));
+                    }
+                  }}
+                  className="mr-2"
+                  disabled={disabled}
+                />
+                <span className="text-sm text-theme-primary">{option.label}</span>
+              </label>
+            ))}
+          </div>
+        );
+
+      default:
+        return <div className="text-theme-error">Unsupported field type: {field.type}</div>;
+    }
+  };
+
+  const handleExport = () => {
+    const data = service.exportProfiles();
+    const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `workflow-schema-profiles-${new Date().toISOString().split('T')[0]}.json`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+  };
+
+  const handleImport = () => {
+    try {
+      const data = JSON.parse(importData);
+      service.importProfiles(data);
+      loadProfiles();
+      setShowImportModal(false);
+      setImportData('');
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to import profiles');
+    }
+  };
+
+  if (editingProfile) {
+    return (
+      <div className="space-y-6">
+        <div className="flex items-center justify-between">
+          <h3 className="text-lg font-medium text-theme-primary">
+            {profiles.some(p => p.id === editingProfile.id) ? 'Edit' : 'Create'} Workflow Profile
+          </h3>
+          <div className="space-x-2">
+            <button
+              onClick={handleSaveProfile}
+              disabled={disabled || editingProfile.roles.length === 0}
+              className="px-4 py-2 btn-theme-primary text-theme-primary-contrast rounded-md disabled:opacity-50"
+            >
+              Save Profile
+            </button>
+            <button
+              onClick={() => setEditingProfile(null)}
+              disabled={disabled}
+              className="px-4 py-2 btn-theme-secondary rounded-md disabled:opacity-50"
+            >
+              Cancel
+            </button>
+          </div>
+        </div>
+
+        {error && (
+          <div className="bg-theme-error/10 border border-theme-error/30 p-3 rounded-md text-theme-error text-sm">
+            {error}
+          </div>
+        )}
+
+        <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+          <div className="space-y-4">
+            <div>
+              <label className="block text-sm font-medium text-theme-primary mb-1">Profile name</label>
+              <input
+                type="text"
+                value={editingProfile.name}
+                onChange={(e) => setEditingProfile({ ...editingProfile, name: e.target.value })}
+                className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary"
+                disabled={disabled}
+              />
+            </div>
+
+            <div>
+              <label className="block text-sm font-medium text-theme-primary mb-1">Description</label>
+              <textarea
+                value={editingProfile.description}
+                onChange={(e) => setEditingProfile({ ...editingProfile, description: e.target.value })}
+                rows={2}
+                className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary"
+                disabled={disabled}
+              />
+            </div>
+
+            <div>
+              <div className="flex items-center justify-between mb-2">
+                <h4 className="font-medium text-theme-primary">Roles</h4>
+                <div className="space-x-1">
+                  {roleTypeSchemas.map((schema) => (
+                    <button
+                      key={schema.id}
+                      onClick={() => handleAddRole(schema.id)}
+                      disabled={disabled}
+                      className="px-2 py-1 btn-theme-secondary text-xs rounded disabled:opacity-50"
+                      title={`Add ${schema.name}`}
+                    >
+                      {schema.icon} {schema.name}
+                    </button>
+                  ))}
+                </div>
+              </div>
+
+              <div className="space-y-2">
+                {editingProfile.roles.map((role, index) => {
+                  const schema = roleTypeSchemas.find(s => s.id === role.typeId);
+                  return (
+                    <div key={role.id} className="border border-theme rounded-md p-3 bg-theme-elevated">
+                      <div className="flex items-center justify-between">
+                        <div>
+                          <span className="font-medium text-theme-primary">
+                            {schema?.icon} {role.name}
+                          </span>
+                          <span className="text-sm text-theme-secondary ml-2">
+                            ({schema?.name})
+                          </span>
+                        </div>
+                        <div className="flex space-x-1">
+                          <button
+                            onClick={() => handleEditRole(role)}
+                            disabled={disabled}
+                            className="p-1 text-theme-accent hover:text-theme-accent-dark disabled:opacity-50"
+                          >
+                            Edit
+                          </button>
+                          <button
+                            onClick={() => handleRemoveRole(role.id)}
+                            disabled={disabled}
+                            className="p-1 text-theme-error hover:text-theme-error-dark disabled:opacity-50"
+                          >
+                            Remove
+                          </button>
+                        </div>
+                      </div>
+                    </div>
+                  );
+                })}
+
+                {editingProfile.roles.length === 0 && (
+                  <div className="text-center py-6 text-theme-secondary">
+                    No roles added yet. Click the buttons above to add roles.
+                  </div>
+                )}
+              </div>
+            </div>
+          </div>
+
+          <div className="space-y-4">
+            <div>
+              <h4 className="font-medium text-theme-primary mb-2">Global settings</h4>
+              <div className="space-y-3">
+                <div>
+                  <label className="block text-sm text-theme-secondary mb-1">Max total iterations</label>
+                  <input
+                    type="number"
+                    value={editingProfile.globalSettings.maxTotalIterations || 15}
+                    onChange={(e) => setEditingProfile({
+                      ...editingProfile,
+                      globalSettings: {
+                        ...editingProfile.globalSettings,
+                        maxTotalIterations: parseInt(e.target.value) || 15
+                      }
+                    })}
+                    min="1"
+                    max="50"
+                    className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary text-sm"
+                    disabled={disabled}
+                  />
+                </div>
+
+                <div>
+                  <label className="block text-sm text-theme-secondary mb-1">Timeout (minutes)</label>
+                  <input
+                    type="number"
+                    value={editingProfile.globalSettings.timeoutMinutes || 30}
+                    onChange={(e) => setEditingProfile({
+                      ...editingProfile,
+                      globalSettings: {
+                        ...editingProfile.globalSettings,
+                        timeoutMinutes: parseInt(e.target.value) || 30
+                      }
+                    })}
+                    min="5"
+                    max="120"
+                    className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary text-sm"
+                    disabled={disabled}
+                  />
+                </div>
+              </div>
+            </div>
+
+            {editingProfile.roles.length > 0 && (
+              <div>
+                <h4 className="font-medium text-theme-primary mb-2">Execution order</h4>
+                <div className="space-y-1">
+                  {editingProfile.executionOrder.map((roleId, index) => {
+                    const role = editingProfile.roles.find(r => r.id === roleId);
+                    const schema = roleTypeSchemas.find(s => s.id === role?.typeId);
+                    return (
+                      <div key={roleId} className="flex items-center text-sm bg-theme-elevated border border-theme rounded p-2">
+                        <span className="w-6 h-6 bg-theme-accent text-theme-primary-contrast rounded-full flex items-center justify-center text-xs mr-2">
+                          {index + 1}
+                        </span>
+                        <span>{schema?.icon} {role?.name}</span>
+                      </div>
+                    );
+                  })}
+                </div>
+              </div>
+            )}
+          </div>
+        </div>
+
+        {/* Role Configuration Modal */}
+        {showRoleModal && editingRole && (
+          <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center p-4 z-50">
+            <div className="bg-theme-primary border border-theme rounded-lg p-6 w-full max-w-2xl max-h-[80vh] overflow-y-auto">
+              <div className="flex items-center justify-between mb-4">
+                <h4 className="text-lg font-medium text-theme-primary">
+                  Configure {roleTypeSchemas.find(s => s.id === editingRole.typeId)?.name}
+                </h4>
+                <div className="space-x-2">
+                  <button
+                    onClick={handleSaveRole}
+                    className="px-4 py-2 btn-theme-primary text-theme-primary-contrast rounded-md"
+                  >
+                    Save Role
+                  </button>
+                  <button
+                    onClick={() => setShowRoleModal(false)}
+                    className="px-4 py-2 btn-theme-secondary rounded-md"
+                  >
+                    Cancel
+                  </button>
+                </div>
+              </div>
+
+              <div className="space-y-4">
+                <div>
+                  <label className="block text-sm font-medium text-theme-primary mb-1">Role name</label>
+                  <input
+                    type="text"
+                    value={editingRole.name}
+                    onChange={(e) => setEditingRole({ ...editingRole, name: e.target.value })}
+                    className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary"
+                  />
+                </div>
+
+                {roleTypeSchemas.find(s => s.id === editingRole.typeId)?.fields.map((field) => (
+                  <div key={field.id}>
+                    <label className="block text-sm font-medium text-theme-primary mb-1">
+                      {field.label}
+                      {field.required && <span className="text-theme-error ml-1">*</span>}
+                    </label>
+                    {renderRoleField(
+                      field,
+                      editingRole.configuration[field.id],
+                      (value) => setEditingRole({
+                        ...editingRole,
+                        configuration: {
+                          ...editingRole.configuration,
+                          [field.id]: value
+                        }
+                      })
+                    )}
+                    {field.helpText && (
+                      <p className="text-xs text-theme-muted mt-1">{field.helpText}</p>
+                    )}
+                  </div>
+                ))}
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-6">
+      <div className="flex items-center justify-between">
+        <h3 className="text-lg font-medium text-theme-primary">Schema-based Role Builder</h3>
+        <div className="space-x-2">
+          <button
+            onClick={handleCreateProfile}
+            disabled={disabled}
+            className="px-4 py-2 btn-theme-primary text-theme-primary-contrast rounded-md disabled:opacity-50"
+          >
+            Create New Profile
+          </button>
+          <button
+            onClick={handleExport}
+            disabled={disabled}
+            className="px-4 py-2 btn-theme-secondary rounded-md disabled:opacity-50"
+          >
+            Export
+          </button>
+          <button
+            onClick={() => setShowImportModal(true)}
+            disabled={disabled}
+            className="px-4 py-2 btn-theme-secondary rounded-md disabled:opacity-50"
+          >
+            Import
+          </button>
+        </div>
+      </div>
+
+      {error && (
+        <div className="bg-theme-error/10 border border-theme-error/30 p-3 rounded-md text-theme-error text-sm">
+          {error}
+        </div>
+      )}
+
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+        <div>
+          <h4 className="font-medium text-theme-primary mb-3">Workflow Profiles</h4>
+          <div className="space-y-2">
+            {profiles.map((profile) => (
+              <div
+                key={profile.id}
+                className={`p-3 border rounded-md cursor-pointer ${
+                  selectedProfile?.id === profile.id
+                    ? 'border-theme-accent bg-theme-accent/10'
+                    : 'border-theme bg-theme-elevated hover:border-theme-accent/50'
+                }`}
+                onClick={() => setSelectedProfile(profile)}
+              >
+                <div className="flex items-center justify-between">
+                  <div>
+                    <h5 className="font-medium text-theme-primary">{profile.name}</h5>
+                    <p className="text-sm text-theme-secondary">{profile.description}</p>
+                    <p className="text-xs text-theme-muted">{profile.roles.length} roles</p>
+                  </div>
+                  <div className="flex space-x-1">
+                    <button
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        handleEditProfile(profile);
+                      }}
+                      disabled={disabled}
+                      className="p-1 text-theme-accent hover:text-theme-accent-dark disabled:opacity-50"
+                    >
+                      Edit
+                    </button>
+                    <button
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        handleDeleteProfile(profile.id);
+                      }}
+                      disabled={disabled || profiles.length <= 1}
+                      className="p-1 text-theme-error hover:text-theme-error-dark disabled:opacity-50"
+                    >
+                      Delete
+                    </button>
+                  </div>
+                </div>
+              </div>
+            ))}
+          </div>
+        </div>
+
+        <div>
+          {selectedProfile && (
+            <>
+              <h4 className="font-medium text-theme-primary mb-3">Profile Preview</h4>
+              <div className="bg-theme-elevated border border-theme rounded-md p-4 space-y-4">
+                <div>
+                  <h5 className="font-medium text-theme-primary">{selectedProfile.name}</h5>
+                  <p className="text-sm text-theme-secondary">{selectedProfile.description}</p>
+                  <p className="text-xs text-theme-muted">Version: {selectedProfile.version}</p>
+                </div>
+
+                <div>
+                  <h6 className="font-medium text-theme-primary mb-2">Roles ({selectedProfile.roles.length})</h6>
+                  <div className="space-y-1">
+                    {selectedProfile.roles.map((role) => {
+                      const schema = roleTypeSchemas.find(s => s.id === role.typeId);
+                      return (
+                        <div key={role.id} className="text-sm border border-theme rounded p-2">
+                          <div className="font-medium text-theme-primary">
+                            {schema?.icon} {role.name}
+                          </div>
+                          <div className="text-theme-secondary">{schema?.name}</div>
+                          <div className="text-theme-muted">
+                            {role.executionSettings.enabled ? 'Enabled' : 'Disabled'}
+                            {role.executionSettings.maxLoops && ` • Max loops: ${role.executionSettings.maxLoops}`}
+                          </div>
+                        </div>
+                      );
+                    })}
+                  </div>
+                </div>
+
+                <div>
+                  <h6 className="font-medium text-theme-primary mb-2">Execution Order</h6>
+                  <div className="space-y-1">
+                    {selectedProfile.executionOrder.map((roleId, index) => {
+                      const role = selectedProfile.roles.find(r => r.id === roleId);
+                      const schema = roleTypeSchemas.find(s => s.id === role?.typeId);
+                      return (
+                        <div key={roleId} className="flex items-center text-sm">
+                          <span className="w-6 h-6 bg-theme-accent text-theme-primary-contrast rounded-full flex items-center justify-center text-xs mr-2">
+                            {index + 1}
+                          </span>
+                          <span>{schema?.icon} {role?.name}</span>
+                        </div>
+                      );
+                    })}
+                  </div>
+                </div>
+              </div>
+            </>
+          )}
+        </div>
+      </div>
+
+      {/* Import Modal */}
+      {showImportModal && (
+        <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center p-4 z-50">
+          <div className="bg-theme-primary border border-theme rounded-lg p-6 w-full max-w-2xl">
+            <h4 className="text-lg font-medium text-theme-primary mb-4">Import Schema Profiles</h4>
+            <textarea
+              value={importData}
+              onChange={(e) => setImportData(e.target.value)}
+              placeholder="Paste JSON data here..."
+              rows={10}
+              className="w-full px-3 py-2 border border-theme rounded-md bg-theme-elevated text-theme-primary text-sm"
+            />
+            <div className="flex justify-end space-x-2 mt-4">
+              <button
+                onClick={() => setShowImportModal(false)}
+                className="px-4 py-2 btn-theme-secondary rounded-md"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={handleImport}
+                disabled={!importData.trim()}
+                className="px-4 py-2 btn-theme-primary text-theme-primary-contrast rounded-md disabled:opacity-50"
+              >
+                Import
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default RoleBuilderTab;
\ No newline at end of file
diff --git a/pages/SettingsPage.tsx b/pages/SettingsPage.tsx
index 459c673..8ea9500 100644
--- a/pages/SettingsPage.tsx
+++ b/pages/SettingsPage.tsx
@@ -5,6 +5,7 @@ import AgentSettingsTab from '../components/settings/AgentSettingsTab';
 import DocumentTypeProfilesTab from '../components/settings/DocumentTypeProfilesTab';
 import GlobalStyleGuideTab from '../components/settings/GlobalStyleGuideTab';
 import { LLMProviderTab } from '../components/settings/LLMProviderTab';
+import RoleBuilderTab from '../components/settings/RoleBuilderTab';
 import { INITIAL_AGENT_SETTINGS } from '../constants';
 import ConfirmModal from '../components/ConfirmModal';
 
@@ -17,7 +18,7 @@ interface SettingsPageProps {
   disabled: boolean; // True if main workflow is processing
 }
 
-type SettingsTab = 'agents' | 'profiles' | 'globalStyle' | 'llmProvider';
+type SettingsTab = 'agents' | 'profiles' | 'globalStyle' | 'llmProvider' | 'roleBuilder';
 
 const SettingsPage: React.FC<SettingsPageProps> = ({
   agentSettings,
@@ -242,6 +243,16 @@ const SettingsPage: React.FC<SettingsPageProps> = ({
             >
               Global style guidance
             </button>
+            <button
+              onClick={() => setActiveTab('roleBuilder')}
+              className={`whitespace-nowrap pb-4 px-1 border-b-2 font-medium text-sm
+                ${activeTab === 'roleBuilder'
+                  ? 'border-theme-accent text-theme-accent'
+                  : 'border-transparent text-theme-secondary hover:text-theme-primary hover:border-theme'
+                }`}
+            >
+              Role builder
+            </button>
           </nav>
         </div>
 
@@ -275,6 +286,11 @@ const SettingsPage: React.FC<SettingsPageProps> = ({
                 disabled={disabled}
             />
           )}
+          {activeTab === 'roleBuilder' && (
+            <RoleBuilderTab
+              disabled={disabled}
+            />
+          )}
         </div>
       </main>
        <footer className="w-full max-w-6xl mt-12 text-center text-xs text-theme-muted">
diff --git a/screenshots/approach-2-main-page.png b/screenshots/approach-2-main-page.png
new file mode 100644
index 0000000..c40f820
Binary files /dev/null and b/screenshots/approach-2-main-page.png differ
diff --git a/screenshots/approach-2-role-builder-tab.png b/screenshots/approach-2-role-builder-tab.png
new file mode 100644
index 0000000..d14597b
Binary files /dev/null and b/screenshots/approach-2-role-builder-tab.png differ
diff --git a/screenshots/approach-2-role-creation.png b/screenshots/approach-2-role-creation.png
new file mode 100644
index 0000000..903a496
Binary files /dev/null and b/screenshots/approach-2-role-creation.png differ
diff --git a/services/roleSchemaService.ts b/services/roleSchemaService.ts
new file mode 100644
index 0000000..bcfa533
--- /dev/null
+++ b/services/roleSchemaService.ts
@@ -0,0 +1,435 @@
+import { 
+  RoleTypeSchema, 
+  ConfigurableRole, 
+  WorkflowSchemaProfile, 
+  ROLE_TYPE_SCHEMAS,
+  RoleFieldSchema 
+} from '../types/roleSchema';
+
+const STORAGE_KEY = 'tech-doc-workflow-schema-profiles';
+const CURRENT_VERSION = '1.0.0';
+
+export class RoleSchemaService {
+  private static instance: RoleSchemaService;
+  private profiles: WorkflowSchemaProfile[] = [];
+
+  private constructor() {
+    this.loadProfiles();
+  }
+
+  static getInstance(): RoleSchemaService {
+    if (!RoleSchemaService.instance) {
+      RoleSchemaService.instance = new RoleSchemaService();
+    }
+    return RoleSchemaService.instance;
+  }
+
+  private loadProfiles(): void {
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      if (stored) {
+        const data = JSON.parse(stored);
+        this.profiles = data.profiles || [];
+      } else {
+        // Create default profile
+        this.profiles = [this.createDefaultProfile()];
+        this.saveProfiles();
+      }
+    } catch (error) {
+      console.warn('Failed to load schema profiles from storage:', error);
+      this.profiles = [this.createDefaultProfile()];
+    }
+  }
+
+  private saveProfiles(): void {
+    try {
+      const data = {
+        version: CURRENT_VERSION,
+        profiles: this.profiles
+      };
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(data, null, 2));
+    } catch (error) {
+      console.error('Failed to save schema profiles to storage:', error);
+      throw new Error('Failed to save workflow profiles');
+    }
+  }
+
+  private createDefaultProfile(): WorkflowSchemaProfile {
+    const now = new Date().toISOString();
+    
+    return {
+      id: 'default-technical-docs',
+      name: 'Technical Documentation Standard',
+      description: 'Standard workflow for technical documentation with configurable roles',
+      version: '1.0.0',
+      roles: [
+        {
+          id: 'writer-1',
+          typeId: 'technical-writer',
+          name: 'Technical Writer',
+          description: 'Primary documentation writer',
+          configuration: {
+            writing_style: 'professional',
+            target_audience: 'developers',
+            include_examples: true,
+            complexity_level: 3,
+            custom_instructions: ''
+          },
+          executionSettings: {
+            enabled: true,
+            timeout: 300,
+            retryCount: 2
+          }
+        },
+        {
+          id: 'reviewer-1',
+          typeId: 'technical-reviewer',
+          name: 'Technical Reviewer',
+          description: 'Reviews technical accuracy',
+          configuration: {
+            review_focus: ['accuracy', 'completeness'],
+            expertise_level: 'senior',
+            strictness_level: 3,
+            must_verify_code: true,
+            review_checklist: ''
+          },
+          executionSettings: {
+            enabled: true,
+            maxLoops: 3,
+            timeout: 180,
+            retryCount: 1
+          }
+        },
+        {
+          id: 'architect-1',
+          typeId: 'information-architect',
+          name: 'Information Architect',
+          description: 'Reviews document structure and flow',
+          configuration: {
+            structure_focus: ['logical_flow', 'heading_hierarchy'],
+            doc_type_expertise: ['how_to', 'explanation'],
+            structure_strictness: 3,
+            require_examples: true
+          },
+          executionSettings: {
+            enabled: true,
+            maxLoops: 2,
+            timeout: 150,
+            retryCount: 1
+          }
+        },
+        {
+          id: 'editor-1',
+          typeId: 'style-editor',
+          name: 'Style Editor',
+          description: 'Reviews writing style and clarity',
+          configuration: {
+            style_guide: 'technical',
+            tone_preference: 'professional',
+            check_grammar: true,
+            check_terminology: true,
+            readability_level: 'professional'
+          },
+          executionSettings: {
+            enabled: true,
+            maxLoops: 2,
+            timeout: 120,
+            retryCount: 1
+          }
+        }
+      ],
+      executionOrder: ['writer-1', 'reviewer-1', 'architect-1', 'editor-1'],
+      globalSettings: {
+        maxTotalIterations: 15,
+        timeoutMinutes: 30,
+        allowParallelReviews: false
+      },
+      metadata: {
+        createdAt: now,
+        updatedAt: now,
+        author: 'System',
+        tags: ['default', 'technical-docs']
+      }
+    };
+  }
+
+  getAllProfiles(): WorkflowSchemaProfile[] {
+    return [...this.profiles];
+  }
+
+  getProfileById(id: string): WorkflowSchemaProfile | undefined {
+    return this.profiles.find(profile => profile.id === id);
+  }
+
+  getRoleTypeSchemas(): RoleTypeSchema[] {
+    return [...ROLE_TYPE_SCHEMAS];
+  }
+
+  getRoleTypeSchema(typeId: string): RoleTypeSchema | undefined {
+    return ROLE_TYPE_SCHEMAS.find(schema => schema.id === typeId);
+  }
+
+  generatePromptForRole(role: ConfigurableRole): string {
+    const schema = this.getRoleTypeSchema(role.typeId);
+    if (!schema) {
+      throw new Error(`Role type schema not found: ${role.typeId}`);
+    }
+
+    let prompt = schema.promptTemplate;
+    
+    // Simple template replacement - replace {{field_id}} with values
+    Object.entries(role.configuration).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        // Handle different value types
+        let replacement = '';
+        if (typeof value === 'boolean') {
+          // For boolean fields, use conditional blocks
+          const positivePattern = new RegExp(`{{#${key}}}([\\s\\S]*?){{/${key}}}`, 'g');
+          const negativePattern = new RegExp(`{{\\^${key}}}([\\s\\S]*?){{/${key}}}`, 'g');
+          
+          if (value) {
+            prompt = prompt.replace(positivePattern, '$1');
+            prompt = prompt.replace(negativePattern, '');
+          } else {
+            prompt = prompt.replace(positivePattern, '');
+            prompt = prompt.replace(negativePattern, '$1');
+          }
+        } else if (Array.isArray(value)) {
+          replacement = value.join(', ');
+        } else {
+          replacement = String(value);
+        }
+        
+        // Replace simple {{field_id}} patterns
+        const pattern = new RegExp(`{{${key}}}`, 'g');
+        prompt = prompt.replace(pattern, replacement);
+      }
+    });
+
+    // Clean up any remaining template syntax
+    prompt = prompt.replace(/{{#\w+}}[\s\S]*?{{\/\w+}}/g, '');
+    prompt = prompt.replace(/{{[\^#\/]\w+}}/g, '');
+    prompt = prompt.replace(/{{[\w_]+}}/g, '');
+
+    return prompt.trim();
+  }
+
+  validateRoleConfiguration(typeId: string, configuration: Record<string, any>): { isValid: boolean; errors: string[] } {
+    const schema = this.getRoleTypeSchema(typeId);
+    if (!schema) {
+      return { isValid: false, errors: [`Unknown role type: ${typeId}`] };
+    }
+
+    const errors: string[] = [];
+
+    schema.fields.forEach(field => {
+      const value = configuration[field.id];
+      
+      // Check required fields
+      if (field.required && (value === undefined || value === null || value === '')) {
+        errors.push(`Field '${field.label}' is required`);
+        return;
+      }
+
+      if (value !== undefined && value !== null && value !== '') {
+        // Type validation
+        switch (field.type) {
+          case 'number':
+            if (typeof value !== 'number' || isNaN(value)) {
+              errors.push(`Field '${field.label}' must be a number`);
+            } else {
+              if (field.min !== undefined && value < field.min) {
+                errors.push(`Field '${field.label}' must be at least ${field.min}`);
+              }
+              if (field.max !== undefined && value > field.max) {
+                errors.push(`Field '${field.label}' must be at most ${field.max}`);
+              }
+            }
+            break;
+            
+          case 'boolean':
+            if (typeof value !== 'boolean') {
+              errors.push(`Field '${field.label}' must be true or false`);
+            }
+            break;
+            
+          case 'select':
+            if (field.options && !field.options.some(opt => opt.value === value)) {
+              errors.push(`Field '${field.label}' must be one of: ${field.options.map(o => o.label).join(', ')}`);
+            }
+            break;
+            
+          case 'multiselect':
+            if (!Array.isArray(value)) {
+              errors.push(`Field '${field.label}' must be an array`);
+            } else if (field.options) {
+              const validValues = field.options.map(opt => opt.value);
+              const invalidValues = value.filter(v => !validValues.includes(v));
+              if (invalidValues.length > 0) {
+                errors.push(`Field '${field.label}' contains invalid values: ${invalidValues.join(', ')}`);
+              }
+            }
+            break;
+            
+          case 'text':
+          case 'textarea':
+            if (typeof value !== 'string') {
+              errors.push(`Field '${field.label}' must be text`);
+            } else if (field.validation) {
+              if (field.validation.minLength && value.length < field.validation.minLength) {
+                errors.push(`Field '${field.label}' must be at least ${field.validation.minLength} characters`);
+              }
+              if (field.validation.maxLength && value.length > field.validation.maxLength) {
+                errors.push(`Field '${field.label}' must be at most ${field.validation.maxLength} characters`);
+              }
+              if (field.validation.pattern && !new RegExp(field.validation.pattern).test(value)) {
+                errors.push(`Field '${field.label}' ${field.validation.message || 'format is invalid'}`);
+              }
+            }
+            break;
+        }
+      }
+    });
+
+    return { isValid: errors.length === 0, errors };
+  }
+
+  addProfile(profile: WorkflowSchemaProfile): void {
+    this.validateProfile(profile);
+    
+    if (this.profiles.some(p => p.id === profile.id)) {
+      throw new Error(`Profile with ID '${profile.id}' already exists`);
+    }
+
+    profile.metadata.updatedAt = new Date().toISOString();
+    this.profiles.push(profile);
+    this.saveProfiles();
+  }
+
+  updateProfile(id: string, updatedProfile: WorkflowSchemaProfile): void {
+    this.validateProfile(updatedProfile);
+    
+    const index = this.profiles.findIndex(p => p.id === id);
+    if (index === -1) {
+      throw new Error(`Profile with ID '${id}' not found`);
+    }
+
+    if (updatedProfile.id !== id && this.profiles.some(p => p.id === updatedProfile.id)) {
+      throw new Error(`Profile with ID '${updatedProfile.id}' already exists`);
+    }
+
+    updatedProfile.metadata.updatedAt = new Date().toISOString();
+    this.profiles[index] = updatedProfile;
+    this.saveProfiles();
+  }
+
+  deleteProfile(id: string): void {
+    const index = this.profiles.findIndex(p => p.id === id);
+    if (index === -1) {
+      throw new Error(`Profile with ID '${id}' not found`);
+    }
+
+    if (this.profiles.length <= 1) {
+      throw new Error('Cannot delete the last workflow profile');
+    }
+
+    this.profiles.splice(index, 1);
+    this.saveProfiles();
+  }
+
+  duplicateProfile(id: string): WorkflowSchemaProfile {
+    const original = this.getProfileById(id);
+    if (!original) {
+      throw new Error(`Profile with ID '${id}' not found`);
+    }
+
+    const duplicate: WorkflowSchemaProfile = {
+      ...original,
+      id: `${original.id}-copy-${Date.now()}`,
+      name: `${original.name} (Copy)`,
+      metadata: {
+        ...original.metadata,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      }
+    };
+
+    this.addProfile(duplicate);
+    return duplicate;
+  }
+
+  private validateProfile(profile: WorkflowSchemaProfile): void {
+    if (!profile.id || typeof profile.id !== 'string') {
+      throw new Error('Profile must have a valid ID');
+    }
+    if (!profile.name || typeof profile.name !== 'string') {
+      throw new Error('Profile must have a valid name');
+    }
+    if (!profile.roles || !Array.isArray(profile.roles) || profile.roles.length === 0) {
+      throw new Error('Profile must have at least one role');
+    }
+
+    // Validate roles
+    profile.roles.forEach((role, index) => {
+      if (!role.id || typeof role.id !== 'string') {
+        throw new Error(`Role at index ${index} must have a valid ID`);
+      }
+      if (!role.typeId || typeof role.typeId !== 'string') {
+        throw new Error(`Role '${role.id}' must have a valid type ID`);
+      }
+      if (!this.getRoleTypeSchema(role.typeId)) {
+        throw new Error(`Role '${role.id}' references unknown type: ${role.typeId}`);
+      }
+
+      // Validate role configuration
+      const validation = this.validateRoleConfiguration(role.typeId, role.configuration);
+      if (!validation.isValid) {
+        throw new Error(`Role '${role.id}' configuration errors: ${validation.errors.join(', ')}`);
+      }
+    });
+
+    // Validate execution order
+    if (!profile.executionOrder || !Array.isArray(profile.executionOrder)) {
+      throw new Error('Profile must have execution order defined');
+    }
+
+    profile.executionOrder.forEach(roleId => {
+      if (!profile.roles.some(role => role.id === roleId)) {
+        throw new Error(`Execution order references non-existent role: ${roleId}`);
+      }
+    });
+
+    // Ensure at least one writer role
+    const hasWriter = profile.roles.some(role => {
+      const schema = this.getRoleTypeSchema(role.typeId);
+      return schema?.category === 'writer';
+    });
+    if (!hasWriter) {
+      throw new Error('Profile must have at least one writer role');
+    }
+  }
+
+  exportProfiles(): { version: string; profiles: WorkflowSchemaProfile[] } {
+    return {
+      version: CURRENT_VERSION,
+      profiles: this.profiles
+    };
+  }
+
+  importProfiles(data: { version: string; profiles: WorkflowSchemaProfile[] }): void {
+    if (!data.profiles || !Array.isArray(data.profiles)) {
+      throw new Error('Invalid import data format');
+    }
+
+    // Validate all profiles before importing
+    data.profiles.forEach(profile => this.validateProfile(profile));
+
+    this.profiles = data.profiles;
+    this.saveProfiles();
+  }
+
+  resetToDefaults(): void {
+    this.profiles = [this.createDefaultProfile()];
+    this.saveProfiles();
+  }
+}
\ No newline at end of file
diff --git a/types/roleSchema.ts b/types/roleSchema.ts
new file mode 100644
index 0000000..af4d5dc
--- /dev/null
+++ b/types/roleSchema.ts
@@ -0,0 +1,438 @@
+// Schema-based role configuration system
+export interface RoleFieldSchema {
+  id: string;
+  label: string;
+  type: 'text' | 'textarea' | 'number' | 'select' | 'boolean' | 'multiselect';
+  required?: boolean;
+  defaultValue?: any;
+  placeholder?: string;
+  options?: { value: string; label: string }[];
+  min?: number;
+  max?: number;
+  validation?: {
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    message?: string;
+  };
+  helpText?: string;
+}
+
+export interface RoleTypeSchema {
+  id: string;
+  name: string;
+  description: string;
+  category: 'writer' | 'reviewer' | 'analyzer' | 'processor';
+  icon?: string;
+  fields: RoleFieldSchema[];
+  promptTemplate: string; // Template with {{field_id}} placeholders
+  defaultSettings?: Record<string, any>;
+}
+
+export interface ConfigurableRole {
+  id: string;
+  typeId: string; // References RoleTypeSchema
+  name: string;
+  description?: string;
+  configuration: Record<string, any>; // Field values
+  generatedPrompt?: string; // Computed from template + configuration
+  executionSettings: {
+    enabled: boolean;
+    maxLoops?: number;
+    timeout?: number;
+    retryCount?: number;
+  };
+}
+
+export interface WorkflowSchemaProfile {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  roles: ConfigurableRole[];
+  executionOrder: string[];
+  globalSettings: {
+    maxTotalIterations?: number;
+    timeoutMinutes?: number;
+    allowParallelReviews?: boolean;
+  };
+  metadata: {
+    createdAt: string;
+    updatedAt: string;
+    author?: string;
+    tags?: string[];
+  };
+}
+
+// Built-in role type schemas
+export const ROLE_TYPE_SCHEMAS: RoleTypeSchema[] = [
+  {
+    id: 'technical-writer',
+    name: 'Technical Writer',
+    description: 'Creates and revises technical documentation',
+    category: 'writer',
+    icon: '✍️',
+    fields: [
+      {
+        id: 'writing_style',
+        label: 'Writing style',
+        type: 'select',
+        required: true,
+        defaultValue: 'professional',
+        options: [
+          { value: 'professional', label: 'Professional and formal' },
+          { value: 'conversational', label: 'Conversational and approachable' },
+          { value: 'technical', label: 'Technical and precise' },
+          { value: 'educational', label: 'Educational and explanatory' }
+        ],
+        helpText: 'Choose the tone and style for the writing'
+      },
+      {
+        id: 'target_audience',
+        label: 'Target audience',
+        type: 'select',
+        required: true,
+        defaultValue: 'developers',
+        options: [
+          { value: 'beginners', label: 'Beginners/newcomers' },
+          { value: 'developers', label: 'Experienced developers' },
+          { value: 'architects', label: 'Technical architects' },
+          { value: 'mixed', label: 'Mixed audience' }
+        ],
+        helpText: 'Primary audience for the documentation'
+      },
+      {
+        id: 'include_examples',
+        label: 'Include code examples',
+        type: 'boolean',
+        defaultValue: true,
+        helpText: 'Whether to include practical code examples'
+      },
+      {
+        id: 'complexity_level',
+        label: 'Complexity level',
+        type: 'number',
+        min: 1,
+        max: 5,
+        defaultValue: 3,
+        helpText: 'Technical complexity level (1=basic, 5=advanced)'
+      },
+      {
+        id: 'custom_instructions',
+        label: 'Custom instructions',
+        type: 'textarea',
+        placeholder: 'Additional specific instructions for this writer...',
+        helpText: 'Any specific requirements or constraints for this writer'
+      }
+    ],
+    promptTemplate: `You are an expert Technical Writer creating {{writing_style}} documentation for {{target_audience}}.
+
+Target audience: {{target_audience}}
+Writing style: {{writing_style}}
+Complexity level: {{complexity_level}}/5
+{{#include_examples}}
+Include practical code examples and demonstrations.
+{{/include_examples}}
+{{#custom_instructions}}
+
+Additional instructions:
+{{custom_instructions}}
+{{/custom_instructions}}
+
+Your task is to create clear, comprehensive technical documentation that serves the needs of your target audience.
+
+Follow these guidelines:
+- Write in active voice when possible
+- Use clear, concise language appropriate for {{target_audience}}
+- Structure content logically with clear headings
+- {{#include_examples}}Include relevant examples and code snippets{{/include_examples}}
+- Follow the provided document template and style guides`,
+    defaultSettings: {
+      maxRetries: 2,
+      timeout: 300
+    }
+  },
+  {
+    id: 'technical-reviewer',
+    name: 'Technical Reviewer',
+    description: 'Reviews documentation for technical accuracy',
+    category: 'reviewer',
+    icon: '🔍',
+    fields: [
+      {
+        id: 'review_focus',
+        label: 'Review focus areas',
+        type: 'multiselect',
+        required: true,
+        defaultValue: ['accuracy', 'completeness'],
+        options: [
+          { value: 'accuracy', label: 'Technical accuracy' },
+          { value: 'completeness', label: 'Completeness of information' },
+          { value: 'code_quality', label: 'Code example quality' },
+          { value: 'security', label: 'Security considerations' },
+          { value: 'performance', label: 'Performance implications' },
+          { value: 'best_practices', label: 'Best practices adherence' }
+        ],
+        helpText: 'Select which aspects to focus on during review'
+      },
+      {
+        id: 'expertise_level',
+        label: 'Reviewer expertise level',
+        type: 'select',
+        required: true,
+        defaultValue: 'senior',
+        options: [
+          { value: 'junior', label: 'Junior reviewer' },
+          { value: 'mid', label: 'Mid-level reviewer' },
+          { value: 'senior', label: 'Senior reviewer' },
+          { value: 'expert', label: 'Subject matter expert' }
+        ],
+        helpText: 'Level of technical expertise for this reviewer'
+      },
+      {
+        id: 'strictness_level',
+        label: 'Review strictness',
+        type: 'number',
+        min: 1,
+        max: 5,
+        defaultValue: 3,
+        helpText: 'How strict should the review be (1=lenient, 5=very strict)'
+      },
+      {
+        id: 'must_verify_code',
+        label: 'Must verify all code examples',
+        type: 'boolean',
+        defaultValue: true,
+        helpText: 'Require verification of all code examples against source'
+      },
+      {
+        id: 'review_checklist',
+        label: 'Custom review checklist',
+        type: 'textarea',
+        placeholder: 'Enter specific items to check during review...',
+        helpText: 'Custom checklist items specific to this reviewer'
+      }
+    ],
+    promptTemplate: `You are a {{expertise_level}} Technical Reviewer with expertise in technical documentation review.
+
+Review focus areas: {{review_focus}}
+Expertise level: {{expertise_level}}
+Review strictness: {{strictness_level}}/5
+{{#must_verify_code}}
+CRITICAL: You must verify all code examples against the provided source code.
+{{/must_verify_code}}
+
+{{#review_checklist}}
+Custom review checklist:
+{{review_checklist}}
+{{/review_checklist}}
+
+Your specialization is technical accuracy and consistency with the provided source code. 
+Review the document for:
+{{#review_focus}}
+- {{.}}
+{{/review_focus}}
+
+CRITICAL INSTRUCTION: You MUST respond in one of the following two formats ONLY:
+
+1. If the document meets all quality standards for your area of expertise and the provided guidance, and requires NO changes:
+
+    CONTINUE
+
+2. If the document requires revisions in your area of expertise or based on the provided guidance:
+
+    REVISE: [Provide very specific, actionable feedback. Clearly state what needs to be changed and why, focusing on your review areas.]
+
+Do not add any text other than specified.`,
+    defaultSettings: {
+      maxLoops: 3,
+      timeout: 180
+    }
+  },
+  {
+    id: 'style-editor',
+    name: 'Style Editor',
+    description: 'Reviews and improves writing style and clarity',
+    category: 'reviewer',
+    icon: '📝',
+    fields: [
+      {
+        id: 'style_guide',
+        label: 'Style guide to follow',
+        type: 'select',
+        required: true,
+        defaultValue: 'technical',
+        options: [
+          { value: 'technical', label: 'Technical writing best practices' },
+          { value: 'ap', label: 'Associated Press (AP) Style' },
+          { value: 'chicago', label: 'Chicago Manual of Style' },
+          { value: 'google', label: 'Google Developer Style Guide' },
+          { value: 'microsoft', label: 'Microsoft Writing Style Guide' },
+          { value: 'custom', label: 'Custom style guide' }
+        ],
+        helpText: 'Which style guide to enforce'
+      },
+      {
+        id: 'tone_preference',
+        label: 'Preferred tone',
+        type: 'select',
+        defaultValue: 'professional',
+        options: [
+          { value: 'formal', label: 'Formal and academic' },
+          { value: 'professional', label: 'Professional but accessible' },
+          { value: 'friendly', label: 'Friendly and conversational' },
+          { value: 'neutral', label: 'Neutral and objective' }
+        ],
+        helpText: 'Desired tone for the documentation'
+      },
+      {
+        id: 'check_grammar',
+        label: 'Check grammar and punctuation',
+        type: 'boolean',
+        defaultValue: true,
+        helpText: 'Whether to review grammar and punctuation'
+      },
+      {
+        id: 'check_terminology',
+        label: 'Check terminology consistency',
+        type: 'boolean',
+        defaultValue: true,
+        helpText: 'Whether to enforce consistent terminology'
+      },
+      {
+        id: 'readability_level',
+        label: 'Target readability level',
+        type: 'select',
+        defaultValue: 'professional',
+        options: [
+          { value: 'simple', label: 'Simple and clear' },
+          { value: 'professional', label: 'Professional level' },
+          { value: 'technical', label: 'Technical complexity acceptable' },
+          { value: 'advanced', label: 'Advanced vocabulary acceptable' }
+        ],
+        helpText: 'Target reading complexity level'
+      }
+    ],
+    promptTemplate: `You are an expert Style Editor specializing in {{style_guide}} style guide compliance.
+
+Style guide: {{style_guide}}
+Preferred tone: {{tone_preference}}
+Target readability: {{readability_level}}
+
+Review focus:
+{{#check_grammar}}
+- Grammar, spelling, and punctuation accuracy
+{{/check_grammar}}
+{{#check_terminology}}
+- Terminology consistency throughout the document
+{{/check_terminology}}
+- Writing clarity and conciseness
+- Tone consistency ({{tone_preference}})
+- Adherence to {{style_guide}} guidelines
+
+Your specialization is technical editing (grammar, spelling, punctuation, style, tone, voice, clarity, conciseness, terminology consistency, and adherence to technical writing best practices).
+
+CRITICAL INSTRUCTION: You MUST respond in one of the following two formats ONLY:
+
+1. If the document meets all quality standards for your area of expertise and the provided guidance, and requires NO changes:
+
+    CONTINUE
+
+2. If the document requires revisions in your area of expertise or based on the provided guidance:
+
+    REVISE: [Provide very specific, actionable feedback. Clearly state what needs to be changed and why, focusing ONLY on style, grammar, and readability improvements.]
+
+Do not add any text other than specified.`,
+    defaultSettings: {
+      maxLoops: 2,
+      timeout: 120
+    }
+  },
+  {
+    id: 'information-architect',
+    name: 'Information Architect',
+    description: 'Reviews document structure and information flow',
+    category: 'reviewer',
+    icon: '🏗️',
+    fields: [
+      {
+        id: 'structure_focus',
+        label: 'Structure focus areas',
+        type: 'multiselect',
+        required: true,
+        defaultValue: ['logical_flow', 'heading_hierarchy'],
+        options: [
+          { value: 'logical_flow', label: 'Logical information flow' },
+          { value: 'heading_hierarchy', label: 'Heading hierarchy and organization' },
+          { value: 'content_grouping', label: 'Content grouping and sections' },
+          { value: 'navigation', label: 'Navigation and cross-references' },
+          { value: 'audience_alignment', label: 'Alignment with target audience' },
+          { value: 'completeness', label: 'Information completeness' }
+        ],
+        helpText: 'Which structural aspects to focus on'
+      },
+      {
+        id: 'doc_type_expertise',
+        label: 'Document type expertise',
+        type: 'multiselect',
+        defaultValue: ['how_to', 'explanation'],
+        options: [
+          { value: 'how_to', label: 'How-to guides' },
+          { value: 'tutorial', label: 'Tutorials' },
+          { value: 'explanation', label: 'Explanation documents' },
+          { value: 'reference', label: 'Reference documentation' },
+          { value: 'api_docs', label: 'API documentation' },
+          { value: 'troubleshooting', label: 'Troubleshooting guides' }
+        ],
+        helpText: 'Types of documents this architect specializes in'
+      },
+      {
+        id: 'structure_strictness',
+        label: 'Structure enforcement level',
+        type: 'number',
+        min: 1,
+        max: 5,
+        defaultValue: 3,
+        helpText: 'How strictly to enforce structural requirements (1=flexible, 5=rigid)'
+      },
+      {
+        id: 'require_examples',
+        label: 'Require practical examples',
+        type: 'boolean',
+        defaultValue: true,
+        helpText: 'Whether to require practical examples in appropriate sections'
+      }
+    ],
+    promptTemplate: `You are an expert Information Architect specializing in {{doc_type_expertise}} documentation structure.
+
+Structure focus areas: {{structure_focus}}
+Document type expertise: {{doc_type_expertise}}
+Structure strictness: {{structure_strictness}}/5
+{{#require_examples}}
+You should ensure practical examples are included where appropriate.
+{{/require_examples}}
+
+Your specialization is information architecture (structure, flow, logical organization, clarity of headings, content grouping, navigation, and overall coherence for the intended audience).
+
+Review the document for:
+{{#structure_focus}}
+- {{.}}
+{{/structure_focus}}
+
+CRITICAL INSTRUCTION: You MUST respond in one of the following two formats ONLY:
+
+1. If the document meets all quality standards for your area of expertise and the provided guidance, and requires NO changes:
+
+    CONTINUE
+
+2. If the document requires revisions in your area of expertise or based on the provided guidance:
+
+    REVISE: [Provide very specific, actionable feedback. Clearly state what needs to be changed and why, focusing ONLY on information architecture and document structure.]
+
+Do not add any text other than specified.`,
+    defaultSettings: {
+      maxLoops: 2,
+      timeout: 150
+    }
+  }
+];
\ No newline at end of file