# Claws Out: Securing and Building with OpenClaw

Nick Taylor

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/xg1zNlzw7Jk-claws-out-securing-building-openclaw) · [Video](https://www.youtube.com/watch?v=xg1zNlzw7Jk)

## Claws Out: Securing and Building with OpenClaw

Nick Taylor’s trusted-proxy contribution removes duplicated authentication work, then supports a live development loop from Discord to an MCP app inside ChatGPT.

Familiarity with reverse proxies, HTTP headers and basic React or TypeScript will help you follow the configuration and MCP app examples.

### Why authenticate again behind a proxy?

[0:15](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=15s)

Why should OpenClaw ask for another credential when an identity-aware proxy already controls access? Nick Taylor, a Montreal-based developer advocate at [Pomerium](https://github.com/pomerium/pomerium), encountered exactly that friction. His February contribution addressed access to OpenClaw’s **control plane**: even after putting a proxy in front of it, he still had to supply a token for the WebSocket connection.

![GitHub issue titled “Allow disabling auth with LAN binding for reverse proxy setups,” showing a summary and proposed solution beside the speaker.](https://ai.engineer/api/talk-essay-media/1a82920febc31403650bd2716ea33ee7543acbd0c5ecbc105487b07e51cc634c)

A GitHub feature request proposes allowing proxy-managed authentication for LAN access.

The duplicated work extended to device pairing. An **identity-aware proxy** combines an identity provider, a policy engine and a reverse proxy—the pattern Taylor introduces through Google Cloud’s IAP. The identity provider establishes who is connecting; policy decides whether that identity may access the application; the proxy gates the connection. Pomerium is an open-core implementation of this approach, but OpenClaw still required its own setup after the proxy had admitted the user.

Taylor opened [issue #1560](https://github.com/openclaw/openclaw/issues/1560), another user running Caddy supported the proposal, and maintainer Peter supplied the feature criteria. The existing flow required pasting an authentication token into the UI for the WebSocket connection. Taylor also reports that the UI put the token in a query string, a behavior he regarded as primarily appropriate for local use. Switching to his phone meant another pairing step, sometimes requiring him to return to another device to complete it.

The resulting [trusted-proxy authentication contribution](https://github.com/openclaw/openclaw/pull/15940) became his first merged OpenClaw contribution. Its central change was to let an explicitly trusted proxy supply the authentication boundary that the gateway had previously required users to satisfy separately.

### Make the trust boundary explicit

[3:59](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=239s)

The configuration separates **which proxy is trusted** from **which headers carry identity**. `gateway.auth.mode` selects `trusted-proxy`; `gateway.trustedProxies` contains one or more addresses for the proxy gating access to the gateway; and `gateway.auth.trustedProxy` contains the identity-header settings.

Within `trustedProxy`, `userHeader` identifies the header used as the user identity, `requiredHeaders` specifies headers that must be present, and optional `allowUsers` restricts accepted identities. Taylor describes a JWT-bearing header in his setup and leaves out `allowUsers` because Pomerium’s policies already determine who may enter. The distinction matters: trusting a header from an authorized proxy is not the same operation as independently validating a JWT signature.

A compact configuration using the email-identity and JWT-assertion separation shown in the [current trusted-proxy guide](https://docs.openclaw.ai/gateway/trusted-proxy-auth) looks like this; `192.0.2.10` stands for the deployment’s actual proxy address:

```json
{
  "gateway": {
    "trustedProxies": ["192.0.2.10"],
    "auth": {
      "mode": "trusted-proxy",
      "trustedProxy": {
        "userHeader": "x-pomerium-claim-email",
        "requiredHeaders": ["x-pomerium-jwt-assertion"]
      }
    }
  }
}
```

The proxy must control the forwarded identity headers, and clients must not be able to bypass it and impersonate that trusted source. Configuration is available through onboarding or the terminal UI.

For Taylor’s demonstrated version, the practical result was no separate WebSocket token and no repeated device pairing. He describes the security improvement as potential, while the reduction in setup friction is immediate. Current OpenClaw documentation adds an explicit browser-approval policy: one-time approval remains required unless `deviceAutoApprove` is enabled, and its default is `false`. The recording’s pairing behavior therefore should not be assumed for a current installation.

### Test the device that has never connected

[5:27](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=327s)

The first implementation missed a pairing-related bug because Taylor tested locally with a device that was already paired. Anthony reported the problem and Sid fixed it. That is a specific testing lesson for authentication changes: **existing session state can hide a broken first-use path**. A successful connection from a familiar browser does not exercise the same conditions as a new device arriving without prior approval.

The contribution also moved through a rapidly changing repository. Taylor started with issue #1560 and [PR #1710](https://github.com/openclaw/openclaw/pull/1710), then went on vacation. He reports that repository numbering advanced from roughly 1,500 to almost 16,000 during his two-week absence. These are issue and pull-request identifiers, not counts of users. He says the original PR was closed as stale, and getting the eventual contribution merged required substantial rebasing.

### McClaw, Discord and a workspace without SSH

[6:51](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=411s)

Taylor’s own instance, McClaw, runs on his desk in Montreal. He primarily talks to it through Discord, with WhatsApp also configured. He previously used Telegram but moved away after his CEO raised concerns about its encryption. The precise distinction is that [Telegram Cloud Chats](https://telegram.org/faq) use client-server encryption, while Secret Chats provide end-to-end encryption; ordinary Telegram conversations are not simply transmitted in plaintext. His choice of Discord is a workflow preference here, not evidence of stronger message confidentiality.

McClaw helped implement the trusted-proxy contribution itself. That exposed a separate permission problem: Taylor gave the agent full access through the GitHub CLI, and it published a pull request before he had finished reviewing the work. He returned the PR to draft. Securing access to an agent’s control plane does not determine what the agent may do with credentials once it is running.

After the authentication feature merged, building from his phone became enjoyable enough that Taylor created [Clawspace](https://github.com/nickytonline/clawspace) through Discord. It lets him browse, read and edit OpenClaw workspace files without opening an SSH session. The value is personal and concrete: a small interface removes a recurring obstacle in his own workflow, without needing to become a tool everyone else adopts.

### Put a live workspace inside ChatGPT

[8:43](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=523s)

The live demonstration starts with a limited MCP app built from an existing template. The [AI Engineer website](https://ai.engineer/europe/2026) exposes developer-facing entry points, including `llms.txt` and an MCP server. Taylor uses the conference as the subject for an app he can register in ChatGPT and then extend through OpenClaw.

The initial connection follows a short sequence:

1. Create the application in ChatGPT and configure OAuth.
2. Register the MCP server and complete the connection.
3. Inspect the available tools: `echo` and `searchSpeakers`.
4. Invoke the app with `Echo hello`.

The tool call returns an associated interface inside the conversation. [MCP Apps](https://modelcontextprotocol.io/extensions/apps/overview) provide this UI extension to MCP: the result can be an interactive widget rather than only text. The Echo widget displays `hello`, exposes action buttons and can be enlarged within ChatGPT.

![An Echo widget in ChatGPT shows “hello” under Echoed Message, with Call Echo Tool, Update Context, Clear, Send to Chat, and Open Docs buttons. Discord is open alongside it.](https://ai.engineer/api/talk-essay-media/fe3f11efb035964088f4ed593045318077397612f44ce3b4cc8d055e1c9fbf62)

ChatGPT displays the embedded Echo interface with the echoed message “hello” and action buttons.

Taylor then asks McClaw to change the echoed message to `AIE EU` in the Echo widget. Underneath the chat interface, this is a web development loop: **React** renders the widget, **Vite** serves the application, and React Refresh with Vite hot module reloading carries workspace edits into the running interface. McClaw changes the MCP app’s files while Taylor remains in ChatGPT.

Two access boundaries make that arrangement work. Trusted-proxy authentication governs access to OpenClaw’s gateway. Separately, Pomerium gates a public URL for the MCP service in the workspace, allowing ChatGPT to reach it through controlled access. Protecting the gateway alone does not automatically protect every service the agent starts; the MCP endpoint needs its own gate. Taylor can then keep developing against the same interface he is using to exercise the app.

### From speaker records to a conversational button

[12:01](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=721s)

Next, Taylor opens a new ChatGPT conversation, selects `@AIE` and invokes `searchSpeakers`. The starting interface is minimal. He asks McClaw to use the conference’s `speakers.json` as the source of speaker records and to give the search interface the same visual style as the Echo widget. The intended result is a directory that can filter speakers and show who is presenting.

The agent takes time to finish, leaving a visible pause in the demonstration. During that wait, Taylor restates the loop: he speaks or types instructions in Discord, OpenClaw edits workspace files, and those files power the publicly reachable, gated app. He also uses **Claude** and **Codex**; this is one useful development workflow among his tools. When McClaw completes the change, the interface supports filtering, selecting a speaker and viewing more information.

The next feature connects the widget back to the host conversation. Taylor asks for a **More** button using `sendMessage`. Rather than making an independent model request inside the widget, this operation sends a user message into the chat that hosts the app. A TypeScript handler using the API illustrated in the [Pomerium MCP app template](https://github.com/pomerium/mcp-app-typescript-template) expresses the mechanism:

```typescript
import { App } from "@modelcontextprotocol/ext-apps";

async function requestTalkDetails(app: App): Promise<void> {
  await app.sendMessage({
    role: "user",
    content: [
      {
        type: "text",
        text: "Tell me more about Alessandro's talk and why I should attend."
      }
    ]
  });
}
```

The button’s click handler supplies the connected app instance. The widget contributes the message; ChatGPT handles the continuation of the conversation.

After the live update adds the button, Taylor clicks it. ChatGPT enters its thinking state, and a new prompt appears in the conversation asking for more about Alessandro’s talk and why it might be worth attending. The progression is now complete: a tool renders a directory, the user chooses an item, and an interaction in that directory asks the host assistant to elaborate.

### Expose the service, preserve the boundary

[15:15](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=915s)

Pomerium is Taylor’s choice for this setup, but he also points to Caddy with OAuth as an alternative. The architectural requirement in his workflow is to make a local service reachable by an external host while retaining an access gate. He briefly mentions NGINX, then narrows his deprecation remark to a Kubernetes ingress controller. The relevant [retirement announcement](https://kubernetes.io/blog/2025/11/11/ingress-nginx-retirement/) concerns the community Ingress NGINX controller, whose maintenance was scheduled to end in March 2026—not NGINX generally.

That infrastructure changes where development can happen. Taylor recalls seeing Replit’s phone-based building experience and wondering why he would ever want to program that way. Now he routinely enjoys building through chat on his phone. Clawspace is his example of the payoff: make a tool that fits the way you actually work, even if its audience is only you.

The freedom still depends on limits. Taylor closes by warning about accidental public exposure and destructive agent actions, including reports of deleted email. Trusted-proxy authentication is useful to him because it makes controlled access less cumbersome; it does not replace careful decisions about which services are exposed or which credentials an agent receives. The invitation is to build personal tools and enjoy the process while keeping those boundaries deliberate.

## Resources

- [The trusted-proxy authentication contribution](https://github.com/openclaw/openclaw/pull/15940) — The merged contribution introducing proxy-based gateway authentication, with configuration examples and review history.
- [Configure trusted-proxy authentication](https://docs.openclaw.ai/gateway/trusted-proxy-auth) — Current configuration and security requirements, including proxy headers, access restrictions and browser device approval.
- [Clawspace](https://github.com/nickytonline/clawspace) — A browser-based OpenClaw workspace file explorer and editor, designed to run behind external access controls.
- [MCP app TypeScript template](https://github.com/pomerium/mcp-app-typescript-template) — Pomerium's starter with a Node.js MCP server, React widgets, an Echo tool and host-conversation interactions.
- [MCP Apps overview](https://modelcontextprotocol.io/extensions/apps/overview) — The official entry point for the MCP Apps extension, including its security model and client support.
- [Telegram encryption FAQ](https://telegram.org/faq) — Explains the distinction between encrypted Cloud Chats and end-to-end encrypted Secret Chats.
- [Ingress NGINX retirement announcement](https://kubernetes.io/blog/2025/11/11/ingress-nginx-retirement/) — Kubernetes' announcement of the community Ingress NGINX controller's planned March 2026 retirement.

## Slides

### AI Engineer Europe

[0:00](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=0s) [AI Engineer Europe logo on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/aab59c7da120f8504a96c9b8622254406bbff88706e2388a912d6dcc744c1118.webp)

AI Engineer
EUROPE

### Presenting Sponsor

[0:05](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=5s) [Google DeepMind presenting sponsor card.](https://assets.ai.engineer/sites/aiecode2025/sha256/22e8cb940ef752894fb0f47ce4cfbb7a04b212fd252bdf1347f3f5879fa393f3.webp)

PRESENTING SPONSOR
Google DeepMind

### Platinum Sponsors

Braintrust, WorkOS, and OpenAI are the platinum sponsors.

[0:10](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=10s) [Platinum sponsor card featuring Braintrust, WorkOS, and OpenAI.](https://assets.ai.engineer/sites/aiecode2025/sha256/35d5bd1433704035b5df29cfc26a829770668098ec7920991f9f1646a40e08fb.webp)

PLATINUM SPONSORS

Braintrust
WorkOS
OpenAI

### About Me

The speaker is a Pomerium developer advocate from Montreal and a GitHub Star, Microsoft MVP, and AWS Community Builder.

[0:21](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=21s) [Speaker introduction listing a developer advocate role, Montreal, and community distinctions, alongside a portrait.](https://assets.ai.engineer/sites/aiecode2025/sha256/9b54caa2f878078e533921015d50d18bad6c0152e881be72ea17a5cbe43dc89f.webp)

About Me

• Developer Advocate at Pomerium
• From Montreal, Quebec, Canada
• GitHub Star, MS MVP, AWS Community Builder
• [redacted] pretty much everywhere

Interface text:
AI Engineer Europe
Presented by Google DeepMind

### Giant red lobster

A giant red lobster towers over a person in a city square. The speaker jokes that it is an on-prem OpenClaw instance, with its operator beneath it.

[0:58](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=58s) [A large red lobster installation in a city square.](https://assets.ai.engineer/sites/aiecode2025/sha256/8e394a689a0db524aa118d4473be367b0b368b4a45a4ad333f5ba19142d6bbb3.webp)

WE ♥
OPEN
[illegible]

Interface text:
Google DeepMind
AI Engineer
EUROPE
Engineering the future of AI

### Reverse proxy authentication request

A Clawdbot user proposes an explicit opt-in to disable gateway authentication when a reverse proxy handles it. The request says forced token authentication breaks browser WebSocket connections on LAN.

[1:06](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=66s) [A GitHub issue proposes an opt-in authentication setting for reverse proxy setups.](https://assets.ai.engineer/sites/aiecode2025/sha256/1e6fec5abe14efc2175faffb9d08e871d82075b2decd289380430464c73ad201.webp)

[Feature]: Allow disabling auth with LAN binding for reverse proxy setups #1560

Summary

I'm trying to secure Clawdbot with Pomerium (an Identity Aware Proxy). Full disclosure, I work at Pomerium. The proxy handles authentication, so Clawdbot doesn't need its own auth.

But when I bind to LAN, Clawdbot forces token authentication. This breaks WebSocket connections because browsers can't pass the token in WebSocket message payloads. The web UI loads but shows "disconnected (1008): unauthorized" for all real-time features.

Proposed solution

Allow gateway.auth: "off" when gateway.bind: "lan" for reverse proxy scenarios.

Could add an explicit opt-in flag like:

{
  gateway: {
    bind: "lan",
    auth: {
      mode: "off",
      allowUnauthenticatedProxy: true
    }
  }
}

This would only work when users explicitly opt in and understand they need a reverse proxy handling auth.

Alternatives considered

Interface text:
Closed
#15940
nickytonline opened on Jan 24 · edited by nickytonline
Edits
Contributor

### Reverse proxy authentication feature request

Pomerium handles authentication for Clawdbot, but LAN binding still forces a token and leaves the real-time UI disconnected. The issue proposes an explicit opt-in to disable gateway auth behind a reverse proxy.

[1:52](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=112s) [The feature request for reverse proxy authentication is shown again.](https://assets.ai.engineer/sites/aiecode2025/sha256/d9274c254facd6b45b9d5afb37ac087186a979adc772f07041ac0e651be3ddc3.webp)

[Feature]: Allow disabling auth with LAN binding for reverse proxy setups #1560

Summary

I'm trying to secure Clawdbot with Pomerium (an Identity Aware Proxy). Full disclosure, I work at Pomerium. The proxy handles authentication, so Clawdbot doesn't need its own auth.

But when I bind to LAN, Clawdbot forces token authentication. This breaks WebSocket connections because browsers can't pass the token in WebSocket message payloads. The web UI loads but shows "disconnected (1008): unauthorized" for all real-time features.

Proposed solution

Allow gateway.auth: "off" when gateway.bind: "lan" for reverse proxy scenarios.

Could add an explicit opt-in flag like:

{
  gateway: {
    bind: "lan",
    auth: {
      mode: "off",
      allowUnauthenticatedProxy: true
    }
  }
}

This would only work when users explicitly opt in and understand they need a reverse proxy handling auth.

Alternatives considered

Interface text:
Closed
#15940
nickytonline opened on Jan 24 · edited by nickytonline
Edits
Contributor
AI Engineer Europe
Presented by Google DeepMind
Braintrust
WorkOS
OpenAI
WE ♥ OPEN

[2:18](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=138s) [A feature request describes WebSocket authentication failures behind a reverse proxy and proposes an explicit opt-in.](https://assets.ai.engineer/sites/aiecode2025/sha256/5a3c48548d3b44647416954797eb96416d5c9daabc5b5e6b1118beae2f9339f2.webp)

[Feature]: Allow disabling auth with LAN binding for reverse proxy setups #1560

Summary

I'm trying to secure Clawdbot with Pomerium (an Identity Aware Proxy). Full disclosure, I work at Pomerium. The proxy handles authentication, so Clawdbot doesn't need its own auth.

But when I bind to LAN, Clawdbot forces token authentication. This breaks WebSocket connections because browsers can't pass the token in WebSocket message payloads. The web UI loads but shows "disconnected (1008): unauthorized" for all real-time features.

Proposed solution

Allow gateway.auth: "off" when gateway.bind: "lan" for reverse proxy scenarios.

Could add an explicit opt-in flag like:

{
  gateway: {
    bind: "lan",
    auth: {
      mode: "off",
      allowUnauthenticatedProxy: true
    }
  }
}

This would only work when users explicitly opt in and understand they need a reverse proxy handling auth.

Alternatives considered

Interface text:
Closed
#15940
nickytonline opened on Jan 24 · edited by nickytonline
Edits
Contributor
AI Engineer Europe
Presented by Google DeepMind
Google DeepMind
WE ♥ OPEN

### Community response to the feature request

A Caddy and Tailscale user backs the request and reports that the gateway crashes after a couple of minutes when exposed this way.

[2:48](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=168s) [A comment describes a gateway crash when using a Caddy and Tailscale setup.](https://assets.ai.engineer/sites/aiecode2025/sha256/0d36ea7a3d8830bb6b0f6b0d686664186479dde8be19c9f3965ea17b110d11be.webp)

marcwestermann on Jan 24

I'd be interested in this too - I have a Caddy setup via tailscale and the gateway crashes after a couple of minutes when exposed via this. Thank you @nickytonline

Interface text:
AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

### Security findings for proxy authentication

Peter welcomed the work but said non-loopback binds with auth disabled need an explicit override. Proxy-only auth also needs server-side trust, such as headers or mTLS, to pass WebSocket authentication.

[3:00](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=180s) [A response lists concerns about non-loopback binding, device identity, and trust for proxy authentication.](https://assets.ai.engineer/sites/aiecode2025/sha256/d1a9b3ccaa0c9adc1b90d34d213095ae3ebfe5c22e88e474f0c0bc9fd81d5f00.webp)

steipete on Jan 24

Hi Nick - yes I'd love if you could work on this. Just needs to be explicit - I don't want folks to leave gates open until they really know what they're doing.

Here some codex notes

Findings

• Critical: core runtime guard explicitly rejects non-loopback binds when auth mode is none; change would be a deliberate security regression and needs a new explicit override + audit/docs updates. src/gateway/server-runtime-config.ts:77 src/security/audit.ts:204
• High: “auth off” does not bypass Control UI device identity on insecure HTTP; without allowInsecureAuth + token/password, the UI is still blocked before auth is even checked. src/gateway/server/ws-connection/message-handler.ts:301
• Medium: 1008 “unauthorized” is triggered by the WS connect auth path; any proxy-only auth still needs a server-side trust mechanism (headers or mTLS), otherwise it fails here. src/gateway/server/ws-connection/message-handler.ts:494

Questions / assumptions

Interface text:
Contributor
AI Engineer EUROPE
Engineering the future of AI

### Prior to trusted proxy auth mode

Even behind a proxy, users had to paste a WebSocket token into the UI and pair each new device. The speaker says the token also appeared in the query string.

[3:07](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=187s) [Before trusted proxy authentication, users still needed a WebSocket authentication token and had to pair each new device.](https://assets.ai.engineer/sites/aiecode2025/sha256/88a701ef60f305dfce1bab47cdaef942986813b8200233df1969455812913b3c.webp)

Prior to trusted proxy auth mode

• Even if secured by a proxy (nginx, Caddy, Pomerium etc.), still had to paste in an auth token in the UI for websocket connections
• Still had to pair for any new device

Interface text:
AI Engineer EUROPE
Engineering the future of AI

[3:37](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=217s) [Slide explaining that users previously had to enter an authentication token and pair each new device even behind a proxy.](https://assets.ai.engineer/sites/aiecode2025/sha256/0dff26d5cda00f30fb96160696622755b5b8266e3e6e838325c0a6a70fa70747.webp)

Prior to trusted proxy auth mode

• Even if secured by a proxy (nginx, Caddy, Pomerium etc.), still had to paste in an auth token in the UI for websocket connections
• Still had to pair for any new device

Interface text:
AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

### Trusted proxy contribution merged

The trusted proxy contribution was the speaker’s first to OpenClaw. The pull request was squash-merged after a positive review.

[3:46](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=226s) [A pull request timeline shows a positive review and the trusted proxy contribution being merged.](https://assets.ai.engineer/sites/aiecode2025/sha256/859b7f7c8fde05adffe64a2b280ba8ef1949653c47b0705e08cfaca7a3083213.webp)

steipete on Feb 14 · Contributor
Great work and clean PR!
❤️ 1

fix: harden trusted-proxy auth follow-ups
279d4b3

steipete force-pushed the feat/trusted-proxy-auth branch from 8d158ac to 279d4b3 2 months ago
Compare

steipete merged commit 1fb52b4 into openclaw:main on Feb 14
13 checks passed
View details · Revert

steipete on Feb 14 · Contributor
Merged via squash.
• Prepared head SHA: 279d4b3
• Merge commit: 1fb52b4
Thanks @nickytonline!
❤️ 1

Interface text:
AI Engineer Europe
Braintrust · WorkOS · OpenAI

### With trusted proxy auth mode

Trusted proxy authentication removes the WebSocket token and device-pairing steps. The speaker calls this a UX win and a potential security improvement.

[5:08](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=308s) [Slide says WebSocket connections no longer need a token and devices no longer need pairing.](https://assets.ai.engineer/sites/aiecode2025/sha256/d672c2636ffbf15c1088569567a920221655137be626e29c6fb0f6abbccf6a31.webp)

With trusted proxy auth mode

• No more token for web socket connections
• No longer need to pair devices

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
Engineering the future of AI

### Reverse-proxy feature issue

While the speaker was on vacation, his original PR was closed as stale. In two weeks, GitHub numbering rose from around 1,500 to almost 16,000; the slide highlights issue #1560 and linked PR #15940.

[6:08](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=368s) [GitHub feature issue about disabling authentication for a reverse-proxy setup, with its linked pull request highlighted.](https://assets.ai.engineer/sites/aiecode2025/sha256/5b5d0878e52ca6efb39756b9894340b3509f300d912be1941fce1e310d2c88b4.webp)

[Feature]: Allow disabling auth with LAN binding for reverse proxy setups #1560
Closed
#15940

Interface text:
openclaw / openclaw
Code
Issues 5k+
Pull requests 5k+
Agents
Actions
More
New issue
AI Engineer EUROPE
Engineering the future of AI

### McClaw: Instagram vs. Reality

McClaw’s Discord profile shows a cartoon lobster. The speaker’s OpenClaw sits on his Montreal desk as a small computer wearing red lobster claws.

[6:50](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=410s) [A cartoon lobster app profile beside a small computer wearing red lobster claws.](https://assets.ai.engineer/sites/aiecode2025/sha256/8085605b311beb38296afa28cbd543198538e6761f920ed837c04a75fbc2ee40.webp)

Instagram vs. Reality

Interface text:
McClaw
APP
AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

[7:18](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=438s) [A McClaw lobster illustration beside a small computer wearing red lobster claws.](https://assets.ai.engineer/sites/aiecode2025/sha256/123cd44974b9777c2324093544e5a0168c9640641f75a0c870c204e27d2be4ee.webp)

Instagram vs. Reality

Interface text:
McClaw
APP
AI Engineer EUROPE
PRESENTED BY Google DeepMind
Google DeepMind

### Clawspace overview

Clawspace brings workspace files and recent changes into a browser interface. Its creator built it on his phone using Discord to read and edit files without SSH.

[7:30](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=450s) [Clawspace overview showing navigation, a filter, and a recent workspace file update.](https://assets.ai.engineer/sites/aiecode2025/sha256/7881fc89358303c6be8d9ee6591e76902503f9dbd086fc8775dc0797c069ae1a.webp)

Welcome to your Clawspace!

Browse all your workspace files and folders in one place. Open the dedicated Workspace page for file browsing, manage visibility in Settings, or open Timeline for a live timeline of changes.

Filters (1 selected)

reports  17 hours ago  created
2026-04-08-weekly-ingress-nginx-digest.md
File updated

# Weekly ingress-nginx replacement digest

Date: 2026-04-08

## Bottom line
The strongest verified market signal is no longer just "recent CVEs." It is the combination of:
(1) ingress-nginx retirement…

More
Path
reports/2026-04-08-weekly-ingress-nginx-digest.md
Open file

reports  18 hours ago  created

Interface text:
Clawspace  Workspace  Timeline
AI Engineer Europe
Presented by Google DeepMind

### Clawspace file editor

Clawspace opens a Markdown report in an editor. The speaker uses it to read and edit workspace files without SSH.

[8:37](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=517s) [Clawspace displays a Markdown report in an editor with edit and preview controls.](https://assets.ai.engineer/sites/aiecode2025/sha256/8f27818d1e05a2f2e76e991349af07e919ce9aa3fddf14a7777239829dd7d910.webp)

# Weekly ingress-nginx replacement digest

Date: 2026-04-08

## Bottom line
The strongest verified market signal is no longer just "recent CVEs." It is the combination of: (1) ingress-nginx retirement and repo archival, (2) fresh CVEs that reinforce the security-risk narrative, and (3) migration tooling/docs from alternatives that explicitly target former ingress-nginx users. That creates a clean opening for Pomerium to position around secure internal access and identity-aware policy, not just generic ingress replacement.

## Verified source takeaways

### 1) The retirement story is real and changes buyer psychology
- Kubernetes officially announced ingress-nginx retirement, with best-effort maintenance only until March 2026, after which there will be no more bugfixes or security updates.

Interface text:
Clawspace  Workspace  Timeline
Workspace / reports / 2026-04-08-weekly-ingress-nginx-digest.md
2026-04-08-weekly-ingress-nginx-digest.md
Edit  Preview
AI Engineer EUROPE
PRESENTED BY Google DeepMind
Braintrust  WorkOS  OpenAI

### Demo

The speaker begins a live-coding demo to build part of an MCP.

[8:43](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=523s) [A black slide with the word Demo in bright green.](https://assets.ai.engineer/sites/aiecode2025/sha256/7a4c4a65ca219c80dddf62e757bc724fc9ec0f137b68c26e8589453dd0c01263.webp)

Demo

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
Braintrust
WorkOS
OpenAI

WE ♥ OPEN SOURCE

### Demo workspace

The demo opens in ChatGPT developer mode beside Discord. Notes outline a speaker-search widget that loads conference speakers, filters them as users type, and opens full details.

[8:54](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=534s) [ChatGPT developer mode beside a Discord window and notes for a speaker-search widget.](https://assets.ai.engineer/sites/aiecode2025/sha256/a0825a79a4df6e335af9f9f19ccdff518e7ef2d42c79a8906006555b1531c5fe.webp)

https://aie.maisonlab.dev/mcp

Change the text “Search Speakers” to “AIE EU 2026 Speakers” in the search_speaker tool’s widget

Update the search_speakers tool’s widget. Fetch https://ai.engineer/europe/speakers.json once at startup and cache in memory. The widget matches the echo widget's visual style. Show all speaker cards on load (avatar, name, role and company), filter in real time as you type using substring match on name, company, role, session title and track. Clicking a card (don’t auto select one) shows the full speaker details in a card component.

Add a more button that calls `sendMessage` with the speakers JSON blob asking the LLM why attendees should see their talk.

Interface text:
Edge  File  Edit  View  History  Favorites  Profiles  Tab  Window  Help
Thu Apr 9 12:56 PM
https://chatgpt.com
ChatGPT
Developer mode
Memory is not used for this chat. Settings
Ask anything
Create image  Write or edit  Look something up

nickytonline's lair
Search nickytonline's lair
Events
Server Boosts
Text Channels
k8s-learnings
events-confs-to...
one-tip-a-week
chats
AIE EU 2026
Voice Channels
General
AIE EU 2026
Started by nickytonline
April 9, 2026
nickytonline  TNKR  12:41 AM
demo
nickytonline  TNKR  9:58 AM
yo
McClaw  APP  9:58 AM
yo (edited)
NEW
Untitled — Edited

### Create an MCP app

The presenter configures the AIE MCP server as a ChatGPT app with OAuth and acknowledges the custom-server warning before building with OpenClaw.

[9:25](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=565s) [New App form with an MCP server address, OAuth selected, and a risk acknowledgment checked.](https://assets.ai.engineer/sites/aiecode2025/sha256/5ccdc8b38afaac3ef6aa6459c2a9893298f4368ec1279501c06b1a0df892b977.webp)

New App BETA

Icon (optional)
PNG only. Minimum size: 128 x 128 px. Max file size: 10 KB

Name
AIE

Description (optional)
Explain what it does in a few words

MCP Server URL
https://aie.maisonlab.dev/mcp

Authentication
OAuth

Advanced settings
Review discovered OAuth settings, or enter them manually, then choose a client setup method and configure default scopes

Custom MCP servers introduce risk. Learn more

I understand and want to continue
OpenAI hasn't reviewed this MCP server. Attackers may attempt to steal your data or trick the model into taking unintended actions, including destroying data.

Read the guide
Create

Notes:
https://aie.maisonlab.dev/mcp

Change the text “Search Speakers” to “AIE EU 2026 Speakers” in the search_speaker tool’s widget

Update the search_speakers tool’s widget. Fetch https://ai.engineer/europe/speakers.json once at startup and cache in memory. The widget matches the echo widget's visual style. Show all speaker cards on load (avatar, name, role and company), filter in real time as you type using substring match on name, company, role, session title and track. Clicking a card (don’t auto select one) shows the full speaker details in a card component.

Add a more button that calls `sendMessage` with the speakers JSON blob asking the LLM why attendees should see their talk.

Interface text:
Edge  File  Edit  View  History  Favorites  Profiles  Tab  Window  Help
Thu Apr 9 12:56 PM
https://chatgpt.com/#settings/Connec...
ChatGPT
nickytonline's lair
Events
Server Boosts
Text Channels
k8s-learnings
events-confs-to...
one-tip-a-week
chats
AIE EU 2026
Voice Channels
General
Started by nickytonline
April 9, 2026
nickytonline  TNKR  12:41 AM
demo
nickytonline  TNKR  9:58 AM
yo
McClaw  APP  9:58 AM
yo (edited)
Untitled — Edited

## Full transcript

[0:00](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=0s) [upbeat music] Yeah.

[0:15](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=15s) So, uh, like, like Phil said, I work at Pomerium, and he's not the first person to have trouble pronouncing it. So I actually convinced the marketing team to, uh, create Pomeranian stickers, so if anybody wants Pomeranian stickers, I have a bunch with me.

[0:31](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=31s) Um, a bit about me. Uh, uh, I'm a, a dev advocate over at Pomerium, as Phil said. Um, from Canada, uh, hailing from Montreal, so, uh, if anybody likes poutine and bagels, feel free to chat with me after.

[0:44](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=44s) Uh, also a GitHub Star, Microsoft MVP, and AWS Community Builder, and these ... You can pretty much find me everywhere, uh, [REDACTED:username] online.

[0:55](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=55s) Um, I was pretty happy to see this, that there's a, a pretty sizable instance on-prem of, uh, OpenClaw, so was pretty happy with that, and it looks like that's the operator there.

[1:08](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=68s) Cool. So, uh, I don't know, I came up with a funny title I guess, but Claws Out. Um, w- we're gonna talk about a feature I contributed to the OpenClaw project back in February, and it's about hardening access to the control plane.

[1:25](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=85s) So, uh, I'm assuming everybody here is running an OpenClaw or OpenClaw-curious. Um, is anybody running, uh, a mode called trusted-proxy auth mode? You, you might not be, but, uh ...

[1:38](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=98s) Okay. You might be on the ... Who's on the token, uh, auth-

[1:42](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=102s) Me.

[1:43](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=103s) Okay. Um, anyways, so at Pomerium where I work, um, you know, I'm always just trying to secure things. That's just part of what I do. And I was able to secure OpenClaw, but it meant I still had to add a token, uh, for the WebSocket connection.

[2:01](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=121s) I had to always pair my device and stuff. And you don't really need that with a, a trusted proxy, like specifically the one that I work on, which is open core.

[2:12](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=132s) It's called an identity-aware proxy. So if anybody's ever used GCP, uh, there's a IAP in there. It's called an identity-aware proxy, something that came out of Google. Uh, essentially you've got an identity provider, a policy engine, and a reverse proxy, so those, uh, it's not the lethal trifecta in the sense that you usually hear, but, uh, it's

[2:33](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=153s) a pretty solid security approach for securing internal apps. So I was like, of course, I, I, I kinda got annoyed that I had to add this token still and do the pairing every time.

[2:44](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=164s) Uh, I understood why they were there, but, uh, I just proposed this issue, and then, uh, at least one other person who uses Caddy, uh, chimed in and said, "Hey, that's, uh, sounds like a good idea."

[2:56](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=176s) And then Peter, uh, stipe, was like, "Yeah, let's, let's work on this," and he laid out, like, the criteria that he wanted to have for this feature. So I went ahead and worked on it.

[3:09](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=189s) And yeah, again, prior to trusted-proxy auth mode, even if you were secured by a proxy, you still had to paste in that auth token in the UI for the WebSocket connection, and also it sticks it in the query string, which, uh, obviously, like this is really more for just only local mode really.

[3:28](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=208s) Um, and still having to pair the device, like, uh, I don't know if people get annoyed by pairing the device, but, uh, I, you know, I'd, I'd just be on a, my phone after I just set it up, and then I was like, "Oh, I gotta go to the other thing to set it up," so.

[3:40](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=220s) Um, basically you still had to do those things even if it was secured with, uh, a proxy.

[3:48](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=228s) So got merged in, and, uh, I felt pretty good about it, and, uh, it was nice to get some praise from Peter. It was, uh, my first contribution to the project, so it was very cool.

[3:59](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=239s) So what does it look like exactly, like in the config? Uh, I'm just gonna show like a, kind of a narrow part of the config here. But you have your gateway, and essentially you no longer need the token, like I mentioned.

[4:13](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=253s) Uh, the mode is obviously different, so it's called trusted-proxy now. And then there's some new properties you have to add. So there's trustedProxies, and this is essentially the proxy that is gating access to the control plane, the, uh, the gateway.

[4:28](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=268s) Um, it's the IP addresses. Uh, it could be one or more. And aside from that, you have to have a trustedProxy section. So you'll have a userHeader, which is in, in my case, uh, it's a JWT, uh, J-W-T.

[4:42](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=282s) Um, and then there's like a requiredHeaders section. There's some optional ones too. It depends what you wanna do. There's like allowUsers, and in my case I don't need the allowUsers because the way a, a identity-aware proxy works is the policies dictate that.

[4:58](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=298s) Um, but essentially that's w- kind of the, the big change there, and you can do this through the onboarding or if you just go back in and, uh, configure things through the TUI.

[5:10](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=310s) And yeah, so that just meant no more token for WebSocket connections and no longer needed to pair devices. So not only are you, uh, getting, uh, better security posture potentially, uh, to me it's like a UX win as well, 'cause, uh, I really found doing these two things annoying.

[5:27](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=327s) Um, cool. Uh, I also just wanna give a shout-out to a couple contributors. After I ch- contributed this, um, there was a bug and Anthony reported it, and then, uh, Sid fixed it, and, uh, it was definitely [laughs] something I missed because I basically was testing this on my local environment, and I already had something paired, so I

[5:51](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=351s) didn't run into the issue that, uh, Anthony had mentioned. So, uh, luckily, uh, it was a small fix and, uh, Sid got that sorted out. But just, uh, you know, when you miss stuff, uh, people in the community step up, so OSS for the win.

[6:07](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=367s) The other thing I want to mention, it's not so much about this feature, but like when I open this issue, um, the number of the issue is [REDACTED:generic_id], and I had a, a PR initially that was like in the 1700s.

[6:21](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=381s) And I went on vacation and I said, "Oh, I'll get back to it [laughs] when I'm back." And the original PR was closed 'cause it was stale and like literally after two weeks it went from like 1,500 to like almost 16,000.

[6:34](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=394s) So, um, basically, that's just a testament to how popular the project got, but it also meant I had to, uh, rebase quite a bit [laughs] before it got merged. So anyways, I don't know if anybody else that contributes to the project, but there's so many things going on all the time, so there's a lot of, uh, rebasing to

[6:51](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=411s) keep your thing up to date. Cool. So, uh, let's talk about my own OpenClaw. So this is McClaw, and he's sitting on my desk in Montreal right now. There's some snow still.

[7:05](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=425s) Um, I use it in Discord. I don't know where people use their OpenClaw. I had it on Telegram initially, but they don't actually, um,

[7:14](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=434s) uh... Their, their, uh, channels aren't encrypted, so like all the stuff's in clear. So I work at a security company, and my CEO is like, "Yeah, don't use that."

[7:23](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=443s) So anyways, uh, I'm mainly on Discord. I find it use- uh, handy that way. I have WhatsApp too, but, uh, I tend to use the Discord more.

[7:32](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=452s) Um, some things I wanna mention too is when I made the contribution, I actually used OpenClaw to make the contribution, which was kind of fun. Um, but it also...

[7:44](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=464s) Uh, I made the mistake of, uh, I used the GitHub CLI, and I gave it full access, so it put up a PR right away even before I was like done reviewing things.

[7:53](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=473s) Uh, so I had a little like, "Ah," but, uh, put it back into draft mode. Um, but aside from that, um, after the, uh, token, uh, trusted proxy mode got merged, I just started working on something.

[8:08](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=488s) It started getting fun to just build stuff on my phone. So I built out something called Clawspace and, you know, doesn't, doesn't mean you need to use it. It's just, you know, it's the age of personal software.

[8:19](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=499s) I just had a lot of fun building it. I find it useful, and I thought it was just cool that I could build this out on my phone on Discord.

[8:26](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=506s) Um, but for me, I find it useful because I don't need to SSH in to see workspace files that I wanna actually read or like edit. Uh, so, um, that's just a little side project I started building, and you can edit files and stuff too.

[8:43](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=523s) Cool. So we're gonna do a demo here. This is gonna be, uh, live coding, [laughs] so YOLO.

[8:52](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=532s) Okay. So, uh, there's a MCP track tomorrow. Uh, I've been doing a lot of work in MCPs. So what we're gonna do is we are going to build out an MCP, uh, not a full-fledged version of something.

[9:06](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=546s) But if you've seen the, uh, AI Engineer website, they have like an llms.txt on the right, and there's a MCP server, and there's a few other things. So I'm gonna go ahead and just add this here.

[9:24](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=564s) And I'm gonna go create an app. I'll explain some things here in a second.

[9:34](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=574s) Okay. And OAuth. Okay. So this is gonna go create an application in ChatGPT. Uh, but basically, this is, uh, an MCP server that just has UI as well. They'll, they'll be talking about this tomorrow.

[9:49](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=589s) But, uh, I have a template that I use for this, so it's not like I'm building this from scratch. But we're just gonna register the MCP here, and then I'm just gonna start building with OpenClaw.

[10:03](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=603s) And the thing with agentic is you never know when it's done. It's just finishing up OAuth here.

[10:12](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=612s) Okay, cool. It's connected, and we can see here it's got two tools. It's got a echo tool, and it's got a searchSpeakers tool.

[10:23](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=623s) So if we come here, if nobody's ever used MCP apps, basically in ChatGPT, you do this for your app. And I'm gonna say like, "Echo hello."

[10:36](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=636s) And essentially, it's going to do the tool call, but because there's UI associated to it, you're gonna get some UI in here. And this is just using the standard MCP stuff that's in the spec now.

[10:50](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=650s) Um, so you can do stuff like change that, make it big and stuff. But what I wanna show is like when I'm building this with OpenClaw, I can do stuff like this.

[10:59](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=659s) I can say like, uh, ba, ba, ba, "Change

[11:05](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=665s) echoed message to AIE EU in the echo widget."

[11:15](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=675s) Now, it's gonna take a second, but, um, this is all web tech under the hood, so I don't know if anybody's, uh, web devs here. But essentially, it's using Vite and React, so there's React Refresh and Vite hot module reloading.

[11:27](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=687s) McClaw is on the case here, and you can see I'm in ChatGPT. I'm editing live from my workspace, the MCP. And, and to explain how this is working, uh, we have the trusted proxy auth mode.

[11:41](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=701s) Uh, I happen to be using Pomerium in this case, so I'm using it as well to secure other things in the workspace. So I have a public URL that I've gated for the MCP, and that's how I'm able to use it in ChatGPT.

[11:53](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=713s) And I can go ahead and just keep working on it in here. And I don't know how other people work or build with, uh, OpenClaw, but this is kinda how I've been doing it.

[12:01](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=721s) I find it works really well for web dev stuff. So I'm gonna go say update the searchSpeakers. So let's just do this, a new chat, and I'll say, "@AIE" again,

[12:14](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=734s) "searchSpeakers."

[12:18](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=738s) And it's gonna give, uh, a very minimal UI here 'cause, uh, there's not much into it. Uh, so I'm gonna just tell McClaw to get on the case here.

[12:27](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=747s) And basically, if you go to that top right corner of the AIE, uh, website, there's a speakers.json, and this is, like, all the speakers from the conf. And we're gonna use that as, like, the source of users, and then I'm asking it to kinda give the same UI as what you kinda saw in the Echo widget.

[12:47](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=767s) Uh, it's gonna take a minute here probably 'cause, uh, McClaw is covered in snow probably in Montreal, but, uh, cool. And so basically once this gets done, uh, we'll be able to filter users and just kind of, you know, see who's talking, um, at the conference.

[13:06](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=786s) And I'm just gonna take a sip of water while McClaw is chugging along there.

[13:19](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=799s) Again, you never know when agentic finishes. Okay, it's determininst- deterministically an indeterminate. So this should be done in a second, and then what you're gonna see is you're gonna see this updated.

[13:35](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=815s) And again, just to reiterate the flow, I- I'm, I'm working in workspace files in my OpenClaw. I'm speaking to it or typing to it in Discord. Uh, this is a publicly available site, uh, and I'm able to build it as I'm in my OpenClaw.

[13:52](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=832s) And I like that workflow. I really don't know how other people work. I mean, obviously I use other tools like Claude and, and Codex too. Um, but you can see here, um,

[14:03](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=843s) McClaw was able to get the job done, and then I can start filtering. So we could look for drilling down here, then we can find a speaker, and then we can get a bit more information.

[14:15](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=855s) And then, like, I could say, let's add another feature here. So let's get McClaw on the case again.

[14:25](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=865s) So we're gonna add a More button here, and there's this sendMessage function that you can use in MCP apps. And this is actually going to, uh, when you click the but- the More button that it's gonna generate, this will actually make a call to the LLM to, a- and you're gonna get a response back.

[14:42](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=882s) Uh, so we'll give this a second. Cool. So I added this More button in.

[14:51](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=891s) Uh, again, like I've been doing web dev for a while, and I, I always still find it magical when things just automatically update. But I'm gonna go ahead and click on here, and you're gonna see here that it's thinking now.

[15:02](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=902s) So it actually made a call, uh, added another, uh, prompt to ChatGPT here, and it's gonna kinda summarize why it thinks you should check out Alessandro's talk and a bit more about it.

[15:15](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=915s) Now, I just really find this workflow really cool. It's only possible if you use some kind of proxy to do this. Uh, you can do this with others like, uh, Caddy with OAuth.

[15:27](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=927s) You could do it with, uh, well, NGINX is kinda deprecated at this point. Or not deprecated, but, uh, at least in Kubernetes land, the Ingress Controller is. Um, but it's just a really nice way to gate stuff that is local, but you can still expose it in a secure way.

[15:44](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=944s) Um, and it's also just fun buil- Like, I don't know about anybody else, but I've been really enjoying building stuff, just chatting. Uh, I remember a couple years ago, uh, Replit, um, who's, who's a AI company that's, you know, making it really easy to build stuff.

[16:00](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=960s) I was like, "Why would I ever wanna build on my phone?" And, uh, I kinda got, uh, phone-pilled now, I guess. So, um, just fu- you know, just having fun.

[16:10](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=970s) I think that's part of the thing with OpenClaw. Also, just, like, use it however you want to. Like, I, I find that Clawspace I created super helpful. Uh, you know, build your own tools and stuff.

[16:21](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=981s) Um, definitely take security into consideration. Uh, you know, there's a bunch of people that have obviously, you know, exposed things and they didn't mean to. Like, you know, some people have deleted all their emails, et cetera.

[16:34](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=994s) Um, but I don't know. I, I find the trusted proxy auth mode super useful and at least one other person [laughs] does in the, in the, in that issue. Um, I encourage you to check it out.

[16:45](https://www.youtube.com/watch?v=xg1zNlzw7Jk&t=1005s) Uh, just have fun building stuff. And yeah, that's, uh, pretty much it. My name is Nick Taylor, and that's how I build with OpenClaw. [audience applauding] [upbeat music]
