diff --git a/src/legacy/core_plugins/data/public/expressions/expression_renderer.tsx b/src/legacy/core_plugins/data/public/expressions/expression_renderer.tsx
index c1899aa9df9a2..c87ab2a7311b6 100644
--- a/src/legacy/core_plugins/data/public/expressions/expression_renderer.tsx
+++ b/src/legacy/core_plugins/data/public/expressions/expression_renderer.tsx
@@ -58,7 +58,7 @@ export const createRenderer = (run: ExpressionRunner): ExpressionRenderer => ({
         }
       });
     }
-  }, [expression, mountpoint.current]);
+  }, [expression, mountpoint.current, options.context, options.getInitialContext]);
 
   return (
     <div
diff --git a/x-pack/legacy/plugins/lens/common/constants.ts b/x-pack/legacy/plugins/lens/common/constants.ts
index eeb295fd776e2..edcc34c58881a 100644
--- a/x-pack/legacy/plugins/lens/common/constants.ts
+++ b/x-pack/legacy/plugins/lens/common/constants.ts
@@ -5,3 +5,9 @@
  */
 
 export const PLUGIN_ID = 'lens';
+
+export const BASE_URL = 'app/lens';
+
+export function getEditPath(id: string) {
+  return `/${BASE_URL}#/edit/${encodeURIComponent(id)}`;
+}
diff --git a/x-pack/legacy/plugins/lens/index.ts b/x-pack/legacy/plugins/lens/index.ts
index d0e550be6e235..36cc18c86b549 100644
--- a/x-pack/legacy/plugins/lens/index.ts
+++ b/x-pack/legacy/plugins/lens/index.ts
@@ -9,7 +9,7 @@ import { Server } from 'hapi';
 import { resolve } from 'path';
 import { LegacyPluginInitializer } from 'src/legacy/types';
 import mappings from './mappings.json';
-import { PLUGIN_ID } from './common';
+import { PLUGIN_ID, getEditPath } from './common';
 
 const NOT_INTERNATIONALIZED_PRODUCT_NAME = 'Lens Visualizations';
 
@@ -26,6 +26,7 @@ export const lens: LegacyPluginInitializer = kibana => {
         description: 'Explore and visualize data.',
         main: `plugins/${PLUGIN_ID}/index`,
       },
+      embeddableFactories: ['plugins/lens/register_embeddable'],
       styleSheetPaths: resolve(__dirname, 'public/index.scss'),
       mappings,
       visTypes: ['plugins/lens/register_vis_type_alias'],
@@ -35,7 +36,7 @@ export const lens: LegacyPluginInitializer = kibana => {
           isImportableAndExportable: true,
           getTitle: (obj: { attributes: { title: string } }) => obj.attributes.title,
           getInAppUrl: (obj: { id: string }) => ({
-            path: `/app/lens#/edit/${encodeURIComponent(obj.id)}`,
+            path: getEditPath(obj.id),
             uiCapabilitiesPath: 'lens.show',
           }),
         },
@@ -63,7 +64,7 @@ export const lens: LegacyPluginInitializer = kibana => {
               all: [],
               read: [],
             },
-            ui: ['show'],
+            ui: ['save', 'show'],
           },
           read: {
             api: [PLUGIN_ID],
diff --git a/x-pack/legacy/plugins/lens/mappings.json b/x-pack/legacy/plugins/lens/mappings.json
index f7bf55fd76a67..9136447531be8 100644
--- a/x-pack/legacy/plugins/lens/mappings.json
+++ b/x-pack/legacy/plugins/lens/mappings.json
@@ -12,6 +12,9 @@
       },
       "state": {
         "type": "text"
+      },
+      "expression": {
+        "type": "text"
       }
     }
   }
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/editor_frame.test.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/editor_frame.test.tsx
index 8dbf80d9afc74..e95e6c982a50c 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/editor_frame.test.tsx
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/editor_frame.test.tsx
@@ -130,12 +130,16 @@ describe('editor_frame', () => {
               activeDatasourceId: 'testDatasource',
               visualizationType: 'testVis',
               title: '',
+              expression: '',
               state: {
                 datasourceStates: {
                   testDatasource: datasource1State,
                   testDatasource2: datasource2State,
                 },
                 visualization: {},
+                datasourceMetaData: {
+                  filterableIndexPatterns: [],
+                },
               },
             }}
           />
@@ -341,38 +345,52 @@ describe('editor_frame', () => {
       instance.update();
 
       expect(instance.find(expressionRendererMock).prop('expression')).toMatchInlineSnapshot(`
-                Object {
-                  "chain": Array [
-                    Object {
-                      "arguments": Object {
-                        "layerIds": Array [
-                          "first",
-                        ],
-                        "tables": Array [
-                          Object {
-                            "chain": Array [
-                              Object {
-                                "arguments": Object {},
-                                "function": "datasource",
-                                "type": "function",
-                              },
-                            ],
-                            "type": "expression",
-                          },
-                        ],
+        Object {
+          "chain": Array [
+            Object {
+              "arguments": Object {},
+              "function": "kibana",
+              "type": "function",
+            },
+            Object {
+              "arguments": Object {
+                "filters": Array [],
+                "query": Array [],
+                "timeRange": Array [],
+              },
+              "function": "kibana_context",
+              "type": "function",
+            },
+            Object {
+              "arguments": Object {
+                "layerIds": Array [
+                  "first",
+                ],
+                "tables": Array [
+                  Object {
+                    "chain": Array [
+                      Object {
+                        "arguments": Object {},
+                        "function": "datasource",
+                        "type": "function",
                       },
-                      "function": "lens_merge_tables",
-                      "type": "function",
-                    },
-                    Object {
-                      "arguments": Object {},
-                      "function": "vis",
-                      "type": "function",
-                    },
-                  ],
-                  "type": "expression",
-                }
-            `);
+                    ],
+                    "type": "expression",
+                  },
+                ],
+              },
+              "function": "lens_merge_tables",
+              "type": "function",
+            },
+            Object {
+              "arguments": Object {},
+              "function": "vis",
+              "type": "function",
+            },
+          ],
+          "type": "expression",
+        }
+      `);
     });
 
     it('should render individual expression for each given layer', async () => {
@@ -398,12 +416,16 @@ describe('editor_frame', () => {
             activeDatasourceId: 'testDatasource',
             visualizationType: 'testVis',
             title: '',
+            expression: '',
             state: {
               datasourceStates: {
                 testDatasource: {},
                 testDatasource2: {},
               },
               visualization: {},
+              datasourceMetaData: {
+                filterableIndexPatterns: [],
+              },
             },
           }}
         />
@@ -416,6 +438,20 @@ describe('editor_frame', () => {
       expect(instance.find(expressionRendererMock).prop('expression')).toMatchInlineSnapshot(`
         Object {
           "chain": Array [
+            Object {
+              "arguments": Object {},
+              "function": "kibana",
+              "type": "function",
+            },
+            Object {
+              "arguments": Object {
+                "filters": Array [],
+                "query": Array [],
+                "timeRange": Array [],
+              },
+              "function": "kibana_context",
+              "type": "function",
+            },
             Object {
               "arguments": Object {
                 "layerIds": Array [
@@ -608,12 +644,16 @@ describe('editor_frame', () => {
             activeDatasourceId: 'testDatasource',
             visualizationType: 'testVis',
             title: '',
+            expression: '',
             state: {
               datasourceStates: {
                 testDatasource: {},
                 testDatasource2: {},
               },
               visualization: {},
+              datasourceMetaData: {
+                filterableIndexPatterns: [],
+              },
             },
           }}
         />
@@ -656,12 +696,16 @@ describe('editor_frame', () => {
             activeDatasourceId: 'testDatasource',
             visualizationType: 'testVis',
             title: '',
+            expression: '',
             state: {
               datasourceStates: {
                 testDatasource: datasource1State,
                 testDatasource2: datasource2State,
               },
               visualization: {},
+              datasourceMetaData: {
+                filterableIndexPatterns: [],
+              },
             },
           }}
         />
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/editor_frame.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/editor_frame.tsx
index cdc0f9c19e21e..12ba3ff6e3192 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/editor_frame.tsx
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/editor_frame.tsx
@@ -162,7 +162,7 @@ export function EditorFrame(props: EditorFrameProps) {
         <nav>
           <EuiLink
             onClick={() => {
-              if (activeDatasource && visualization) {
+              if (state.activeDatasourceId && activeDatasource && visualization) {
                 save({
                   activeDatasources: Object.keys(state.datasourceStates).reduce(
                     (datasourceMap, datasourceId) => ({
@@ -176,6 +176,8 @@ export function EditorFrame(props: EditorFrameProps) {
                   state,
                   redirectTo: props.redirectTo,
                   store: props.store,
+                  activeDatasourceId: state.activeDatasourceId,
+                  framePublicAPI,
                 }).catch(onError);
               }
             }}
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/expression_helpers.ts b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/expression_helpers.ts
index 3cc5beed0669b..46498a00591b5 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/expression_helpers.ts
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/expression_helpers.ts
@@ -4,6 +4,9 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
+import { TimeRange } from 'ui/timefilter/time_history';
+import { Query } from 'src/legacy/core_plugins/data/public';
+import { Filter } from '@kbn/es-query';
 import { Ast, fromExpression, ExpressionFunctionAST } from '@kbn/interpreter/common';
 import { Visualization, Datasource, FramePublicAPI } from '../../types';
 
@@ -59,6 +62,39 @@ export function prependDatasourceExpression(
   };
 }
 
+export function prependKibanaContext(
+  expression: Ast | string | null,
+  {
+    timeRange,
+    query,
+    filters,
+  }: {
+    timeRange?: TimeRange;
+    query?: Query;
+    filters?: Filter[];
+  }
+): Ast | null {
+  if (!expression) return null;
+  const parsedExpression = typeof expression === 'string' ? fromExpression(expression) : expression;
+
+  return {
+    type: 'expression',
+    chain: [
+      { type: 'function', function: 'kibana', arguments: {} },
+      {
+        type: 'function',
+        function: 'kibana_context',
+        arguments: {
+          timeRange: timeRange ? [JSON.stringify(timeRange)] : [],
+          query: query ? [JSON.stringify(query)] : [],
+          filters: filters ? [JSON.stringify(filters)] : [],
+        },
+      },
+      ...parsedExpression.chain,
+    ],
+  };
+}
+
 export function buildExpression({
   visualization,
   visualizationState,
@@ -83,5 +119,8 @@ export function buildExpression({
   }
   const visualizationExpression = visualization.toExpression(visualizationState, framePublicAPI);
 
-  return prependDatasourceExpression(visualizationExpression, datasourceMap, datasourceStates);
+  return prependKibanaContext(
+    prependDatasourceExpression(visualizationExpression, datasourceMap, datasourceStates),
+    {}
+  );
 }
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/save.test.ts b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/save.test.ts
index fd93b005572fa..fe829c70cc063 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/save.test.ts
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/save.test.ts
@@ -6,18 +6,20 @@
 
 import { save, Props } from './save';
 import { Action } from './state_management';
-import { createMockDatasource } from '../mocks';
+import { createMockDatasource, createMockVisualization } from '../mocks';
 
 describe('save editor frame state', () => {
+  const mockVisualization = createMockVisualization();
+  mockVisualization.getPersistableState.mockImplementation(x => x);
+  const mockDatasource = createMockDatasource();
+  mockDatasource.getPersistableState.mockImplementation(x => x);
   const saveArgs: Props = {
     dispatch: jest.fn(),
     redirectTo: jest.fn(),
     activeDatasources: {
-      indexpattern: {
-        getPersistableState: x => x,
-      },
+      indexpattern: mockDatasource,
     },
-    visualization: { getPersistableState: x => x },
+    visualization: mockVisualization,
     state: {
       title: 'aaa',
       datasourceStates: {
@@ -30,6 +32,14 @@ describe('save editor frame state', () => {
       saving: false,
       visualization: { activeId: '2', state: {} },
     },
+    activeDatasourceId: 'indexpattern',
+    framePublicAPI: {
+      addNewLayer: jest.fn(),
+      removeLayer: jest.fn(),
+      datasourceLayers: {
+        first: mockDatasource.publicAPIMock,
+      },
+    },
     store: {
       async save() {
         return { id: 'foo' };
@@ -92,6 +102,10 @@ describe('save editor frame state', () => {
       stuff: `${state}_datasource_persisted`,
     }));
 
+    const visualization = createMockVisualization();
+    visualization.getPersistableState.mockImplementation(state => ({
+      things: `${state}_vis_persisted`,
+    }));
     await save({
       ...saveArgs,
       activeDatasources: {
@@ -110,20 +124,17 @@ describe('save editor frame state', () => {
         saving: false,
         visualization: { activeId: '3', state: '4' },
       },
-
-      visualization: {
-        getPersistableState(state) {
-          return {
-            things: `${state}_vis_persisted`,
-          };
-        },
-      },
+      visualization,
     });
 
     expect(store.save).toHaveBeenCalledWith({
       activeDatasourceId: 'indexpattern',
       id: undefined,
+      expression: '',
       state: {
+        datasourceMetaData: {
+          filterableIndexPatterns: [],
+        },
         datasourceStates: {
           indexpattern: {
             stuff: '2_datasource_persisted',
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/save.ts b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/save.ts
index 723a193750e10..91d32e996a45d 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/save.ts
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/save.ts
@@ -4,16 +4,22 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
+import _ from 'lodash';
+import { toExpression } from '@kbn/interpreter/target/common';
 import { Action, EditorFrameState } from './state_management';
 import { Document } from '../../persistence/saved_object_store';
+import { buildExpression } from './expression_helpers';
+import { Datasource, Visualization, FramePublicAPI } from '../../types';
 
 export interface Props {
-  activeDatasources: Record<string, { getPersistableState: (state: unknown) => unknown }>;
+  activeDatasources: Record<string, Datasource>;
   dispatch: (value: Action) => void;
   redirectTo: (path: string) => void;
   state: EditorFrameState;
   store: { save: (doc: Document) => Promise<{ id: string }> };
-  visualization: { getPersistableState: (state: unknown) => unknown };
+  visualization: Visualization;
+  framePublicAPI: FramePublicAPI;
+  activeDatasourceId: string;
 }
 
 export async function save({
@@ -23,23 +29,44 @@ export async function save({
   state,
   store,
   visualization,
+  framePublicAPI,
+  activeDatasourceId,
 }: Props) {
   try {
     dispatch({ type: 'SAVING', isSaving: true });
 
+    const expression = buildExpression({
+      visualization,
+      visualizationState: state.visualization.state,
+      datasourceMap: activeDatasources,
+      datasourceStates: state.datasourceStates,
+      framePublicAPI,
+    });
+
     const datasourceStates: Record<string, unknown> = {};
     Object.entries(activeDatasources).forEach(([id, datasource]) => {
       datasourceStates[id] = datasource.getPersistableState(state.datasourceStates[id].state);
     });
 
+    const filterableIndexPatterns: string[] = [];
+    Object.entries(activeDatasources).forEach(([id, datasource]) => {
+      filterableIndexPatterns.push(
+        ...datasource.getMetaData(state.datasourceStates[id].state).filterableIndexPatterns
+      );
+    });
+
     const doc = await store.save({
       id: state.persistedId,
       title: state.title,
       type: 'lens',
       visualizationType: state.visualization.activeId,
-      activeDatasourceId: state.activeDatasourceId!,
+      expression: expression ? toExpression(expression) : '',
+      activeDatasourceId,
       state: {
         datasourceStates,
+        datasourceMetaData: {
+          filterableIndexPatterns: _.uniq(filterableIndexPatterns),
+        },
         visualization: visualization.getPersistableState(state.visualization.state),
       },
     });
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/state_management.test.ts b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/state_management.test.ts
index b7b44bbb16688..e02614ffb4be5 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/state_management.test.ts
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/state_management.test.ts
@@ -48,12 +48,16 @@ describe('editor_frame state management', () => {
         ...props,
         doc: {
           activeDatasourceId: 'testDatasource',
+          expression: '',
           state: {
             datasourceStates: {
               testDatasource: { internalState1: '' },
               testDatasource2: { internalState2: '' },
             },
             visualization: {},
+            datasourceMetaData: {
+              filterableIndexPatterns: [],
+            },
           },
           title: '',
           visualizationType: 'testVis',
@@ -423,8 +427,10 @@ describe('editor_frame state management', () => {
           type: 'VISUALIZATION_LOADED',
           doc: {
             id: 'b',
+            expression: '',
             activeDatasourceId: 'a',
             state: {
+              datasourceMetaData: { filterableIndexPatterns: [] },
               datasourceStates: { a: { foo: 'c' } },
               visualization: { bar: 'd' },
             },
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/workspace_panel.test.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/workspace_panel.test.tsx
index 85054d8f7c702..5a7b50851e847 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/workspace_panel.test.tsx
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/workspace_panel.test.tsx
@@ -138,38 +138,52 @@ describe('workspace_panel', () => {
     );
 
     expect(instance.find(expressionRendererMock).prop('expression')).toMatchInlineSnapshot(`
-            Object {
-              "chain": Array [
-                Object {
-                  "arguments": Object {
-                    "layerIds": Array [
-                      "first",
-                    ],
-                    "tables": Array [
-                      Object {
-                        "chain": Array [
-                          Object {
-                            "arguments": Object {},
-                            "function": "datasource",
-                            "type": "function",
-                          },
-                        ],
-                        "type": "expression",
-                      },
-                    ],
-                  },
-                  "function": "lens_merge_tables",
-                  "type": "function",
-                },
+      Object {
+        "chain": Array [
+          Object {
+            "arguments": Object {},
+            "function": "kibana",
+            "type": "function",
+          },
+          Object {
+            "arguments": Object {
+              "filters": Array [],
+              "query": Array [],
+              "timeRange": Array [],
+            },
+            "function": "kibana_context",
+            "type": "function",
+          },
+          Object {
+            "arguments": Object {
+              "layerIds": Array [
+                "first",
+              ],
+              "tables": Array [
                 Object {
-                  "arguments": Object {},
-                  "function": "vis",
-                  "type": "function",
+                  "chain": Array [
+                    Object {
+                      "arguments": Object {},
+                      "function": "datasource",
+                      "type": "function",
+                    },
+                  ],
+                  "type": "expression",
                 },
               ],
-              "type": "expression",
-            }
-        `);
+            },
+            "function": "lens_merge_tables",
+            "type": "function",
+          },
+          Object {
+            "arguments": Object {},
+            "function": "vis",
+            "type": "function",
+          },
+        ],
+        "type": "expression",
+      }
+    `);
   });
 
   it('should include data fetching for each layer in the expression', () => {
@@ -214,44 +228,44 @@ describe('workspace_panel', () => {
     );
 
     expect(
-      (instance.find(expressionRendererMock).prop('expression') as Ast).chain[0].arguments.layerIds
+      (instance.find(expressionRendererMock).prop('expression') as Ast).chain[2].arguments.layerIds
     ).toEqual(['first', 'second', 'third']);
     expect(
-      (instance.find(expressionRendererMock).prop('expression') as Ast).chain[0].arguments.tables
+      (instance.find(expressionRendererMock).prop('expression') as Ast).chain[2].arguments.tables
     ).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "chain": Array [
-            Object {
-              "arguments": Object {},
-              "function": "datasource",
-              "type": "function",
-            },
-          ],
-          "type": "expression",
-        },
-        Object {
-          "chain": Array [
-            Object {
-              "arguments": Object {},
-              "function": "datasource2",
-              "type": "function",
-            },
-          ],
-          "type": "expression",
-        },
-        Object {
-          "chain": Array [
-            Object {
-              "arguments": Object {},
-              "function": "datasource2",
-              "type": "function",
-            },
-          ],
-          "type": "expression",
-        },
-      ]
-    `);
+            Array [
+              Object {
+                "chain": Array [
+                  Object {
+                    "arguments": Object {},
+                    "function": "datasource",
+                    "type": "function",
+                  },
+                ],
+                "type": "expression",
+              },
+              Object {
+                "chain": Array [
+                  Object {
+                    "arguments": Object {},
+                    "function": "datasource2",
+                    "type": "function",
+                  },
+                ],
+                "type": "expression",
+              },
+              Object {
+                "chain": Array [
+                  Object {
+                    "arguments": Object {},
+                    "function": "datasource2",
+                    "type": "function",
+                  },
+                ],
+                "type": "expression",
+              },
+            ]
+        `);
   });
 
   describe('expression failures', () => {
@@ -286,7 +300,7 @@ describe('workspace_panel', () => {
         />
       );
 
-      expect(instance.find('[data-test-subj="expression-failure"]')).toHaveLength(1);
+      expect(instance.find('[data-test-subj="expression-failure"]').first()).toBeTruthy();
       expect(instance.find(expressionRendererMock)).toHaveLength(0);
     });
 
@@ -330,7 +344,7 @@ describe('workspace_panel', () => {
 
       instance.update();
 
-      expect(instance.find('[data-test-subj="expression-failure"]')).toHaveLength(1);
+      expect(instance.find('EuiFlexItem[data-test-subj="expression-failure"]')).toHaveLength(1);
       expect(instance.find(expressionRendererMock)).toHaveLength(0);
     });
 
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/workspace_panel.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/workspace_panel.tsx
index 84c3ac25503fc..eb0496605cc1c 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/workspace_panel.tsx
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/editor_frame/workspace_panel.tsx
@@ -6,7 +6,7 @@
 
 import React, { useState, useEffect, useMemo, useContext } from 'react';
 import { FormattedMessage } from '@kbn/i18n/react';
-import { EuiCodeBlock, EuiSpacer } from '@elastic/eui';
+import { EuiCodeBlock, EuiFlexGroup, EuiFlexItem } from '@elastic/eui';
 import { toExpression } from '@kbn/interpreter/common';
 import { ExpressionRenderer } from '../../../../../../../src/legacy/core_plugins/data/public';
 import { Action } from './state_management';
@@ -119,22 +119,23 @@ export function InnerWorkspacePanel({
 
     if (expressionError) {
       return (
-        <>
-          <p data-test-subj="expression-failure">
+        <EuiFlexGroup direction="column">
+          <EuiFlexItem data-test-subj="expression-failure">
             {/* TODO word this differently because expressions should not be exposed at this level */}
             <FormattedMessage
               id="xpack.lens.editorFrame.expressionFailure"
               defaultMessage="Expression could not be executed successfully"
             />
-          </p>
+          </EuiFlexItem>
           {expression && (
-            <>
+            <EuiFlexItem>
               <EuiCodeBlock>{toExpression(expression)}</EuiCodeBlock>
-              <EuiSpacer />
-            </>
+            </EuiFlexItem>
           )}
-          <EuiCodeBlock>{JSON.stringify(expressionError, null, 2)}</EuiCodeBlock>
-        </>
+          <EuiFlexItem>
+            <EuiCodeBlock>{JSON.stringify(expressionError, null, 2)}</EuiCodeBlock>
+          </EuiFlexItem>
+        </EuiFlexGroup>
       );
     } else {
       return (
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/embeddable.test.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/embeddable.test.tsx
new file mode 100644
index 0000000000000..762b5eff86a20
--- /dev/null
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/embeddable.test.tsx
@@ -0,0 +1,148 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { Embeddable } from './embeddable';
+import { TimeRange } from 'ui/timefilter/time_history';
+import { Query, ExpressionRendererProps } from 'src/legacy/core_plugins/data/public';
+import { Filter } from '@kbn/es-query';
+import { Document } from '../../persistence';
+import { act } from 'react-dom/test-utils';
+
+const savedVis: Document = {
+  activeDatasourceId: '',
+  expression: 'my | expression',
+  state: {
+    visualization: {},
+    datasourceStates: {},
+    datasourceMetaData: {
+      filterableIndexPatterns: [],
+    },
+  },
+  title: 'My title',
+  visualizationType: '',
+};
+
+describe('embeddable', () => {
+  let mountpoint: HTMLDivElement;
+  let expressionRenderer: jest.Mock<null, [ExpressionRendererProps]>;
+
+  beforeEach(() => {
+    mountpoint = document.createElement('div');
+    expressionRenderer = jest.fn(_props => null);
+  });
+
+  afterEach(() => {
+    mountpoint.remove();
+  });
+
+  it('should render expression with expression renderer', () => {
+    const embeddable = new Embeddable(
+      expressionRenderer,
+      {
+        editUrl: '',
+        editable: true,
+        savedVis,
+      },
+      { id: '123' }
+    );
+    embeddable.render(mountpoint);
+
+    expect(expressionRenderer).toHaveBeenCalledTimes(1);
+    expect(expressionRenderer.mock.calls[0][0]!.expression).toEqual(savedVis.expression);
+  });
+
+  it('should display error if expression renderering fails', () => {
+    const embeddable = new Embeddable(
+      expressionRenderer,
+      {
+        editUrl: '',
+        editable: true,
+        savedVis,
+      },
+      { id: '123' }
+    );
+    embeddable.render(mountpoint);
+
+    act(() => {
+      expressionRenderer.mock.calls[0][0]!.onRenderFailure!({ type: 'error' });
+    });
+
+    expect(mountpoint.innerHTML).toContain("Visualization couldn't be displayed");
+  });
+
+  it('should re-render if new input is pushed', () => {
+    const timeRange: TimeRange = { from: 'now-15d', to: 'now' };
+    const query: Query = { language: 'kquery', query: '' };
+    const filters: Filter[] = [{ meta: { alias: 'test', negate: false, disabled: false } }];
+
+    const embeddable = new Embeddable(
+      expressionRenderer,
+      {
+        editUrl: '',
+        editable: true,
+        savedVis,
+      },
+      { id: '123' }
+    );
+    embeddable.render(mountpoint);
+
+    embeddable.updateInput({
+      timeRange,
+      query,
+      filters,
+    });
+
+    expect(expressionRenderer).toHaveBeenCalledTimes(2);
+  });
+
+  it('should pass context in getInitialContext handler', () => {
+    const timeRange: TimeRange = { from: 'now-15d', to: 'now' };
+    const query: Query = { language: 'kquery', query: '' };
+    const filters: Filter[] = [{ meta: { alias: 'test', negate: false, disabled: false } }];
+
+    const embeddable = new Embeddable(
+      expressionRenderer,
+      {
+        editUrl: '',
+        editable: true,
+        savedVis,
+      },
+      { id: '123', timeRange, query, filters }
+    );
+    embeddable.render(mountpoint);
+
+    expect(expressionRenderer.mock.calls[0][0].getInitialContext!()).toEqual({
+      timeRange,
+      query,
+      filters,
+    });
+  });
+
+  it('should not re-render if only change is in disabled filter', () => {
+    const timeRange: TimeRange = { from: 'now-15d', to: 'now' };
+    const query: Query = { language: 'kquery', query: '' };
+    const filters: Filter[] = [{ meta: { alias: 'test', negate: false, disabled: true } }];
+
+    const embeddable = new Embeddable(
+      expressionRenderer,
+      {
+        editUrl: '',
+        editable: true,
+        savedVis,
+      },
+      { id: '123', timeRange, query, filters }
+    );
+    embeddable.render(mountpoint);
+
+    embeddable.updateInput({
+      timeRange,
+      query,
+      filters: [{ meta: { alias: 'test', negate: true, disabled: true } }],
+    });
+
+    expect(expressionRenderer).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/embeddable.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/embeddable.tsx
new file mode 100644
index 0000000000000..318cff621a9d9
--- /dev/null
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/embeddable.tsx
@@ -0,0 +1,145 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import _ from 'lodash';
+import React from 'react';
+import { render, unmountComponentAtNode } from 'react-dom';
+
+import { TimeRange } from 'ui/timefilter/time_history';
+import { Query, StaticIndexPattern, ExpressionRenderer } from 'src/legacy/core_plugins/data/public';
+import { Filter } from '@kbn/es-query';
+import { Subscription } from 'rxjs';
+import {
+  Embeddable as AbstractEmbeddable,
+  EmbeddableOutput,
+  IContainer,
+  EmbeddableInput,
+} from '../../../../../../../src/legacy/core_plugins/embeddable_api/public/index';
+import { Document, DOC_TYPE } from '../../persistence';
+import { ExpressionWrapper } from './expression_wrapper';
+
+export interface LensEmbeddableConfiguration {
+  savedVis: Document;
+  editUrl: string;
+  editable: boolean;
+  indexPatterns?: StaticIndexPattern[];
+}
+
+export interface LensEmbeddableInput extends EmbeddableInput {
+  timeRange?: TimeRange;
+  query?: Query;
+  filters?: Filter[];
+}
+
+export interface LensEmbeddableOutput extends EmbeddableOutput {
+  indexPatterns?: StaticIndexPattern[];
+}
+
+export class Embeddable extends AbstractEmbeddable<LensEmbeddableInput, LensEmbeddableOutput> {
+  type = DOC_TYPE;
+
+  private expressionRenderer: ExpressionRenderer;
+  private savedVis: Document;
+  private domNode: HTMLElement | Element | undefined;
+  private subscription: Subscription;
+
+  private currentContext: {
+    timeRange?: TimeRange;
+    query?: Query;
+    filters?: Filter[];
+    lastReloadRequestTime?: number;
+  } = {};
+
+  constructor(
+    expressionRenderer: ExpressionRenderer,
+    { savedVis, editUrl, editable, indexPatterns }: LensEmbeddableConfiguration,
+    initialInput: LensEmbeddableInput,
+    parent?: IContainer
+  ) {
+    super(
+      initialInput,
+      {
+        defaultTitle: savedVis.title,
+        savedObjectId: savedVis.id!,
+        editable,
+        // passing edit url and index patterns to the output of this embeddable for
+        // the container to pick them up and use them to configure filter bar and
+        // config dropdown correctly.
+        editUrl,
+        indexPatterns,
+      },
+      parent
+    );
+
+    this.expressionRenderer = expressionRenderer;
+    this.savedVis = savedVis;
+    this.subscription = this.getInput$().subscribe(input => this.onContainerStateChanged(input));
+    this.onContainerStateChanged(initialInput);
+  }
+
+  onContainerStateChanged(containerState: LensEmbeddableInput) {
+    const cleanedFilters = containerState.filters
+      ? containerState.filters.filter(filter => !filter.meta.disabled)
+      : undefined;
+    if (
+      !_.isEqual(containerState.timeRange, this.currentContext.timeRange) ||
+      !_.isEqual(containerState.query, this.currentContext.query) ||
+      !_.isEqual(cleanedFilters, this.currentContext.filters)
+    ) {
+      this.currentContext = {
+        timeRange: containerState.timeRange,
+        query: containerState.query,
+        lastReloadRequestTime: this.currentContext.lastReloadRequestTime,
+        filters: cleanedFilters,
+      };
+
+      if (this.domNode) {
+        this.render(this.domNode);
+      }
+    }
+  }
+
+  /**
+   *
+   * @param {HTMLElement} domNode
+   * @param {ContainerState} containerState
+   */
+  render(domNode: HTMLElement | Element) {
+    this.domNode = domNode;
+    render(
+      <ExpressionWrapper
+        ExpressionRenderer={this.expressionRenderer}
+        expression={this.savedVis.expression}
+        context={this.currentContext}
+      />,
+      domNode
+    );
+  }
+
+  destroy() {
+    super.destroy();
+    if (this.domNode) {
+      unmountComponentAtNode(this.domNode);
+    }
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+    }
+  }
+
+  reload() {
+    const currentTime = Date.now();
+    if (this.currentContext.lastReloadRequestTime !== currentTime) {
+      this.currentContext = {
+        ...this.currentContext,
+        lastReloadRequestTime: currentTime,
+      };
+
+      if (this.domNode) {
+        this.render(this.domNode);
+      }
+    }
+  }
+}
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/embeddable_factory.ts b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/embeddable_factory.ts
new file mode 100644
index 0000000000000..d0615c9a7b54b
--- /dev/null
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/embeddable_factory.ts
@@ -0,0 +1,103 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import _ from 'lodash';
+import { Chrome } from 'ui/chrome';
+
+import { capabilities } from 'ui/capabilities';
+import { i18n } from '@kbn/i18n';
+import { DataSetup, ExpressionRenderer } from 'src/legacy/core_plugins/data/public';
+import {
+  EmbeddableFactory as AbstractEmbeddableFactory,
+  ErrorEmbeddable,
+  EmbeddableInput,
+  IContainer,
+} from '../../../../../../../src/legacy/core_plugins/embeddable_api/public/index';
+import { Embeddable } from './embeddable';
+import { SavedObjectIndexStore, DOC_TYPE } from '../../persistence';
+import { getEditPath } from '../../../common';
+
+export class EmbeddableFactory extends AbstractEmbeddableFactory {
+  type = DOC_TYPE;
+
+  private chrome: Chrome;
+  private indexPatternService: DataSetup['indexPatterns']['indexPatterns'];
+  private expressionRenderer: ExpressionRenderer;
+
+  constructor(
+    chrome: Chrome,
+    expressionRenderer: ExpressionRenderer,
+    indexPatternService: DataSetup['indexPatterns']
+  ) {
+    super({
+      savedObjectMetaData: {
+        name: i18n.translate('xpack.lens.lensSavedObjectLabel', {
+          defaultMessage: 'Lens Visualization',
+        }),
+        type: DOC_TYPE,
+        getIconForSavedObject: () => 'faceHappy',
+      },
+    });
+    this.chrome = chrome;
+    this.indexPatternService = indexPatternService.indexPatterns;
+    this.expressionRenderer = expressionRenderer;
+  }
+
+  public isEditable() {
+    return capabilities.get().lens.save as boolean;
+  }
+
+  canCreateNew() {
+    return false;
+  }
+
+  getDisplayName() {
+    return i18n.translate('xpack.lens.embeddableDisplayName', {
+      defaultMessage: 'lens',
+    });
+  }
+
+  async createFromSavedObject(
+    savedObjectId: string,
+    input: Partial<EmbeddableInput> & { id: string },
+    parent?: IContainer
+  ) {
+    const store = new SavedObjectIndexStore(this.chrome.getSavedObjectsClient());
+    const savedVis = await store.load(savedObjectId);
+
+    const promises = savedVis.state.datasourceMetaData.filterableIndexPatterns.map(
+      async indexPatternId => {
+        try {
+          return await this.indexPatternService.get(indexPatternId);
+        } catch (error) {
+          // Unable to load index pattern, ignore error as the index patterns are only used to
+          // configure the filter and query bar - there is still a good chance to get the visualization
+          // to show.
+          return null;
+        }
+      }
+    );
+    const indexPatterns = (await Promise.all(promises)).filter(indexPattern =>
+      Boolean(indexPattern)
+    );
+
+    return new Embeddable(
+      this.expressionRenderer,
+      {
+        savedVis,
+        editUrl: this.chrome.addBasePath(getEditPath(savedObjectId)),
+        editable: this.isEditable(),
+        indexPatterns,
+      },
+      input,
+      parent
+    );
+  }
+
+  async create(input: EmbeddableInput) {
+    return new ErrorEmbeddable('Lens can only be created from a saved object', input);
+  }
+}
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/expression_wrapper.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/expression_wrapper.tsx
new file mode 100644
index 0000000000000..d5ba7bcd39118
--- /dev/null
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/embeddable/expression_wrapper.tsx
@@ -0,0 +1,69 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import _ from 'lodash';
+import React, { useState, useEffect } from 'react';
+
+import { I18nProvider } from '@kbn/i18n/react';
+import { FormattedMessage } from '@kbn/i18n/react';
+import { EuiFlexGroup, EuiFlexItem, EuiText, EuiIcon } from '@elastic/eui';
+import { TimeRange } from 'ui/timefilter/time_history';
+import { Query } from 'src/legacy/core_plugins/data/public';
+import { Filter } from '@kbn/es-query';
+import { ExpressionRenderer } from '../../../../../../../src/legacy/core_plugins/data/public';
+
+export interface ExpressionWrapperProps {
+  ExpressionRenderer: ExpressionRenderer;
+  expression: string;
+  context: {
+    timeRange?: TimeRange;
+    query?: Query;
+    filters?: Filter[];
+    lastReloadRequestTime?: number;
+  };
+}
+
+export function ExpressionWrapper({
+  ExpressionRenderer: ExpressionRendererComponent,
+  expression,
+  context,
+}: ExpressionWrapperProps) {
+  const [expressionError, setExpressionError] = useState<unknown>(undefined);
+  useEffect(() => {
+    // reset expression error if component attempts to run it again
+    if (expressionError) {
+      setExpressionError(undefined);
+    }
+  }, [expression, context]);
+  return (
+    <I18nProvider>
+      {expression === '' || expressionError ? (
+        <EuiFlexGroup direction="column" alignItems="center" justifyContent="center">
+          <EuiFlexItem>
+            <EuiIcon type="alert" color="danger" />
+          </EuiFlexItem>
+          <EuiFlexItem>
+            <EuiText size="s">
+              <FormattedMessage
+                id="xpack.lens.embeddable.failure"
+                defaultMessage="Visualization couldn't be displayed"
+              />
+            </EuiText>
+          </EuiFlexItem>
+        </EuiFlexGroup>
+      ) : (
+        <ExpressionRendererComponent
+          className="lnsExpressionOutput"
+          expression={expression}
+          onRenderFailure={(e: unknown) => {
+            setExpressionError(e);
+          }}
+          getInitialContext={() => context}
+        />
+      )}
+    </I18nProvider>
+  );
+}
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/mocks.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/mocks.tsx
index 225b9802f113d..ad30f84165d2c 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/mocks.tsx
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/mocks.tsx
@@ -11,7 +11,7 @@ import { EditorFrameSetupPlugins } from './plugin';
 
 export function createMockVisualization(): jest.Mocked<Visualization> {
   return {
-    getPersistableState: jest.fn(_state => ({})),
+    getPersistableState: jest.fn(_state => _state),
     getSuggestions: jest.fn(_options => []),
     initialize: jest.fn((_frame, _state?) => ({})),
     renderConfigPanel: jest.fn(),
@@ -45,6 +45,7 @@ export function createMockDatasource(): DatasourceMock {
     insertLayer: jest.fn((_state, _newLayerId) => {}),
     removeLayer: jest.fn((_state, _layerId) => {}),
     getLayers: jest.fn(_state => []),
+    getMetaData: jest.fn(_state => ({ filterableIndexPatterns: [] })),
 
     // this is an additional property which doesn't exist on real datasources
     // but can be used to validate whether specific API mock functions are called
@@ -83,6 +84,12 @@ export function createMockDependencies() {
         run: jest.fn(_ => Promise.resolve({ type: 'render', as: 'test', value: undefined })),
       },
     },
+    embeddables: {
+      addEmbeddableFactory: jest.fn(),
+    },
+    chrome: {
+      getSavedObjectsClient: () => {},
+    },
     interpreter: {
       functionsRegistry: {
         register: jest.fn(),
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/plugin.test.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/plugin.test.tsx
index 93ac1475b795e..80cfe4598cbd4 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/plugin.test.tsx
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/plugin.test.tsx
@@ -13,7 +13,7 @@ import {
   createMockVisualization,
 } from './mocks';
 import { SavedObjectStore, Document } from '../persistence';
-import { shallow, mount } from 'enzyme';
+import { mountWithIntl as mount, shallowWithIntl as shallow } from 'test_utils/enzyme_helpers';
 
 jest.mock('ui/chrome', () => ({
   getSavedObjectsClient: jest.fn(),
@@ -22,6 +22,8 @@ jest.mock('ui/chrome', () => ({
 // mock away actual dependencies to prevent all of it being loaded
 jest.mock('../../../../../../src/legacy/core_plugins/interpreter/public/registries', () => {});
 jest.mock('../../../../../../src/legacy/core_plugins/data/public/setup', () => {});
+jest.mock('../../../../../../src/legacy/core_plugins/embeddable_api/public', () => {});
+jest.mock('./embeddable/embeddable_factory', () => ({ EmbeddableFactory: class Mock {} }));
 
 function mockStore(): SavedObjectStore {
   return {
@@ -78,12 +80,16 @@ describe('editor_frame plugin', () => {
     it('should load the document, if persistedId is defined', async () => {
       const doc: Document = {
         id: 'hoi',
+        expression: '',
         activeDatasourceId: 'indexpattern',
         state: {
           datasourceStates: {
             indexpattern: 'foo',
           },
           visualization: 'bar',
+          datasourceMetaData: {
+            filterableIndexPatterns: [],
+          },
         },
         title: 'shazm',
         visualizationType: 'fanci',
@@ -192,11 +198,15 @@ describe('editor_frame plugin', () => {
           doc={{
             activeDatasourceId: 'b',
             visualizationType: 'd',
+            expression: '',
             state: {
-              visualization: 'viz',
+              datasourceMetaData: {
+                filterableIndexPatterns: [],
+              },
               datasourceStates: {
                 b: 'data',
               },
+              visualization: 'viz',
             },
             title: 'ttt',
           }}
diff --git a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/plugin.tsx b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/plugin.tsx
index 359ac72bbd379..fac75fe421d59 100644
--- a/x-pack/legacy/plugins/lens/public/editor_frame_plugin/plugin.tsx
+++ b/x-pack/legacy/plugins/lens/public/editor_frame_plugin/plugin.tsx
@@ -10,7 +10,11 @@ import { Registry } from '@kbn/interpreter/target/common';
 import { I18nProvider } from '@kbn/i18n/react';
 import { CoreSetup } from 'src/core/public';
 import { HashRouter, Switch, Route, RouteComponentProps } from 'react-router-dom';
-import chrome from 'ui/chrome';
+import chrome, { Chrome } from 'ui/chrome';
+import {
+  EmbeddablePlugin,
+  embeddablePlugin,
+} from '../../../../../../src/legacy/core_plugins/embeddable_api/public';
 import {
   DataSetup,
   ExpressionRenderer,
@@ -29,6 +33,14 @@ import { EditorFrame } from './editor_frame';
 import { SavedObjectIndexStore, SavedObjectStore, Document } from '../persistence';
 import { InitializableComponent } from './initializable_component';
 import { mergeTables } from './merge_tables';
+import { EmbeddableFactory } from './embeddable/embeddable_factory';
+
+export interface EditorFrameSetupPlugins {
+  data: DataSetup;
+  chrome: Chrome;
+  embeddables: EmbeddablePlugin;
+  interpreter: InterpreterSetup;
+}
 
 export interface InterpreterSetup {
   functionsRegistry: Registry<
@@ -37,11 +49,6 @@ export interface InterpreterSetup {
   >;
 }
 
-export interface EditorFrameSetupPlugins {
-  data: DataSetup;
-  interpreter: InterpreterSetup;
-}
-
 interface InitializationResult {
   doc?: Document;
   error?: { message: string };
@@ -66,13 +73,14 @@ export class EditorFramePlugin {
   constructor() {}
 
   private ExpressionRenderer: ExpressionRenderer | null = null;
+  private chrome: Chrome | null = null;
   private readonly datasources: Record<string, Datasource> = {};
   private readonly visualizations: Record<string, Visualization> = {};
 
   private createInstance(): EditorFrameInstance {
     let domElement: Element;
 
-    const store = new SavedObjectIndexStore(chrome.getSavedObjectsClient());
+    const store = new SavedObjectIndexStore(this.chrome!.getSavedObjectsClient());
 
     function unmount() {
       if (domElement) {
@@ -128,6 +136,11 @@ export class EditorFramePlugin {
     plugins.interpreter.functionsRegistry.register(() => mergeTables);
 
     this.ExpressionRenderer = plugins.data.expressions.ExpressionRenderer;
+    this.chrome = plugins.chrome;
+    plugins.embeddables.addEmbeddableFactory(
+      new EmbeddableFactory(plugins.chrome, this.ExpressionRenderer, plugins.data.indexPatterns)
+    );
+
     return {
       createInstance: this.createInstance.bind(this),
       registerDatasource: (name, datasource) => {
@@ -149,6 +162,8 @@ const editorFrame = new EditorFramePlugin();
 export const editorFrameSetup = () =>
   editorFrame.setup(null, {
     data,
+    chrome,
+    embeddables: embeddablePlugin,
     interpreter: {
       functionsRegistry,
     },
diff --git a/x-pack/legacy/plugins/lens/public/index.ts b/x-pack/legacy/plugins/lens/public/index.ts
index aec29edaa728a..8e232e878e91a 100644
--- a/x-pack/legacy/plugins/lens/public/index.ts
+++ b/x-pack/legacy/plugins/lens/public/index.ts
@@ -14,6 +14,8 @@ import 'uiExports/fieldFormats';
 import 'uiExports/search';
 import 'uiExports/visRequestHandlers';
 import 'uiExports/visResponseHandlers';
+// Used for kibana_context function
+import 'uiExports/savedObjectTypes';
 
 import { render, unmountComponentAtNode } from 'react-dom';
 import { IScope } from 'angular';
diff --git a/x-pack/legacy/plugins/lens/public/indexpattern_plugin/indexpattern.tsx b/x-pack/legacy/plugins/lens/public/indexpattern_plugin/indexpattern.tsx
index 67639346a3ad1..87a85d37ec1d2 100644
--- a/x-pack/legacy/plugins/lens/public/indexpattern_plugin/indexpattern.tsx
+++ b/x-pack/legacy/plugins/lens/public/indexpattern_plugin/indexpattern.tsx
@@ -284,6 +284,14 @@ export function getIndexPatternDatasource({
 
     toExpression,
 
+    getMetaData(state: IndexPatternPrivateState) {
+      return {
+        filterableIndexPatterns: _.uniq(
+          Object.values(state.layers).map(layer => layer.indexPatternId)
+        ),
+      };
+    },
+
     renderDataPanel(
       domElement: Element,
       props: DatasourceDataPanelProps<IndexPatternPrivateState>
diff --git a/x-pack/legacy/plugins/lens/public/persistence/saved_object_store.test.ts b/x-pack/legacy/plugins/lens/public/persistence/saved_object_store.test.ts
index f46164d9abb9f..0f57fea6fb4a4 100644
--- a/x-pack/legacy/plugins/lens/public/persistence/saved_object_store.test.ts
+++ b/x-pack/legacy/plugins/lens/public/persistence/saved_object_store.test.ts
@@ -26,8 +26,10 @@ describe('LensStore', () => {
       const doc = await store.save({
         title: 'Hello',
         visualizationType: 'bar',
+        expression: '',
         activeDatasourceId: 'indexpattern',
         state: {
+          datasourceMetaData: { filterableIndexPatterns: [] },
           datasourceStates: {
             indexpattern: { type: 'index_pattern', indexPattern: '.kibana_test' },
           },
@@ -39,8 +41,10 @@ describe('LensStore', () => {
         id: 'FOO',
         title: 'Hello',
         visualizationType: 'bar',
+        expression: '',
         activeDatasourceId: 'indexpattern',
         state: {
+          datasourceMetaData: { filterableIndexPatterns: [] },
           datasourceStates: {
             indexpattern: { type: 'index_pattern', indexPattern: '.kibana_test' },
           },
@@ -52,8 +56,11 @@ describe('LensStore', () => {
       expect(client.create).toHaveBeenCalledWith('lens', {
         title: 'Hello',
         visualizationType: 'bar',
+
+        expression: '',
         activeDatasourceId: 'indexpattern',
         state: JSON.stringify({
+          datasourceMetaData: { filterableIndexPatterns: [] },
           datasourceStates: {
             indexpattern: { type: 'index_pattern', indexPattern: '.kibana_test' },
           },
@@ -68,8 +75,10 @@ describe('LensStore', () => {
         id: 'Gandalf',
         title: 'Even the very wise cannot see all ends.',
         visualizationType: 'line',
+        expression: '',
         activeDatasourceId: 'indexpattern',
         state: {
+          datasourceMetaData: { filterableIndexPatterns: [] },
           datasourceStates: {
             indexpattern: { type: 'index_pattern', indexPattern: 'lotr' },
           },
@@ -81,8 +90,10 @@ describe('LensStore', () => {
         id: 'Gandalf',
         title: 'Even the very wise cannot see all ends.',
         visualizationType: 'line',
+        expression: '',
         activeDatasourceId: 'indexpattern',
         state: {
+          datasourceMetaData: { filterableIndexPatterns: [] },
           datasourceStates: {
             indexpattern: { type: 'index_pattern', indexPattern: 'lotr' },
           },
@@ -94,8 +105,10 @@ describe('LensStore', () => {
       expect(client.update).toHaveBeenCalledWith('lens', 'Gandalf', {
         title: 'Even the very wise cannot see all ends.',
         visualizationType: 'line',
+        expression: '',
         activeDatasourceId: 'indexpattern',
         state: JSON.stringify({
+          datasourceMetaData: { filterableIndexPatterns: [] },
           datasourceStates: {
             indexpattern: { type: 'index_pattern', indexPattern: 'lotr' },
           },
diff --git a/x-pack/legacy/plugins/lens/public/persistence/saved_object_store.ts b/x-pack/legacy/plugins/lens/public/persistence/saved_object_store.ts
index d90f1d4514174..74619909832d4 100644
--- a/x-pack/legacy/plugins/lens/public/persistence/saved_object_store.ts
+++ b/x-pack/legacy/plugins/lens/public/persistence/saved_object_store.ts
@@ -5,6 +5,7 @@
  */
 
 import { SavedObjectAttributes } from 'target/types/server';
+import { DatasourceMetaData } from '../types';
 
 export interface Document {
   id?: string;
@@ -12,14 +13,15 @@ export interface Document {
   visualizationType: string | null;
   title: string;
   activeDatasourceId: string;
-  // The state is saved as a JSON string for now
+  expression: string;
   state: {
+    datasourceMetaData: DatasourceMetaData;
     datasourceStates: Record<string, unknown>;
     visualization: unknown;
   };
 }
 
-const DOC_TYPE = 'lens';
+export const DOC_TYPE = 'lens';
 
 interface SavedObjectClient {
   create: (type: string, object: SavedObjectAttributes) => Promise<{ id: string }>;
diff --git a/x-pack/legacy/plugins/lens/public/register_embeddable.ts b/x-pack/legacy/plugins/lens/public/register_embeddable.ts
new file mode 100644
index 0000000000000..0364b1a4eb65b
--- /dev/null
+++ b/x-pack/legacy/plugins/lens/public/register_embeddable.ts
@@ -0,0 +1,17 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { indexPatternDatasourceSetup } from './indexpattern_plugin';
+import { xyVisualizationSetup } from './xy_visualization_plugin';
+import { editorFrameSetup } from './editor_frame_plugin';
+import { datatableVisualizationSetup } from './datatable_visualization_plugin';
+
+// bootstrap shimmed plugins to register everything necessary (expression functions and embeddables).
+// the new platform will take care of this once in place.
+indexPatternDatasourceSetup();
+datatableVisualizationSetup();
+xyVisualizationSetup();
+editorFrameSetup();
diff --git a/x-pack/legacy/plugins/lens/public/types.ts b/x-pack/legacy/plugins/lens/public/types.ts
index 3c75377991b3e..c099daca02c5f 100644
--- a/x-pack/legacy/plugins/lens/public/types.ts
+++ b/x-pack/legacy/plugins/lens/public/types.ts
@@ -44,6 +44,10 @@ export interface DatasourceSuggestion<T = unknown> {
   table: TableSuggestion;
 }
 
+export interface DatasourceMetaData {
+  filterableIndexPatterns: string[];
+}
+
 /**
  * Interface for the datasource registry
  */
@@ -64,6 +68,8 @@ export interface Datasource<T = unknown, P = unknown> {
 
   toExpression: (state: T, layerId: string) => Ast | string | null;
 
+  getMetaData: (state: T) => DatasourceMetaData;
+
   getDatasourceSuggestionsForField: (state: T, field: unknown) => Array<DatasourceSuggestion<T>>;
   getDatasourceSuggestionsFromCurrentState: (state: T) => Array<DatasourceSuggestion<T>>;
 
diff --git a/x-pack/legacy/plugins/lens/public/xy_visualization_plugin/xy_expression.tsx b/x-pack/legacy/plugins/lens/public/xy_visualization_plugin/xy_expression.tsx
index f65c8c990b976..2e6b00d3ec506 100644
--- a/x-pack/legacy/plugins/lens/public/xy_visualization_plugin/xy_expression.tsx
+++ b/x-pack/legacy/plugins/lens/public/xy_visualization_plugin/xy_expression.tsx
@@ -98,7 +98,7 @@ function getIconForSeriesType(seriesType: SeriesType): IconType {
 export function XYChart({ data, args }: XYChartProps) {
   const { legend, layers } = args;
 
-  if (Object.values(data.tables).some(table => table.rows.length === 0)) {
+  if (Object.values(data.tables).every(table => table.rows.length === 0)) {
     const icon: IconType = layers.length > 0 ? getIconForSeriesType(layers[0].seriesType) : 'bar';
     return (
       <EuiFlexGroup gutterSize="s" direction="column" alignItems="center" justifyContent="center">
@@ -144,7 +144,7 @@ export function XYChart({ data, args }: XYChartProps) {
 
       {layers.map(
         ({ splitAccessor, seriesType, accessors, xAccessor, layerId, columnToLabel }, index) => {
-          if (!data.tables[layerId]) {
+          if (!data.tables[layerId] || data.tables[layerId].rows.length === 0) {
             return;
           }