diff --git a/src/server/routes/note.ts b/src/server/routes/note.ts
--- a/src/server/routes/note.ts
+++ b/src/server/routes/note.ts
@@ -280,5 +280,6 @@ noteSlug,
 			noteTitle: data.note.title,
 			content: data.current.content,
 			sidebarNotes,
+			canonicalRecord: data.note,
 		});
 	});
diff --git a/src/server/routes/render-note.ts b/src/server/routes/render-note.ts
--- a/src/server/routes/render-note.ts
+++ b/src/server/routes/render-note.ts
@@ -7,7 +7,11 @@ import { noteUrl, resolvePublicUrl } from "../../lib/urls.ts";
 import { resolveBookmarkHtml } from "../../views/bookmark.ts";
 import { notePage } from "../../views/note.ts";
 import { shareOnBlueskyButton } from "../../views/share.ts";
-import { wikiIdentity, wikiLayoutOptions } from "../../views/view-options.ts";
+import {
+	atCanonicalOption,
+	wikiIdentity,
+	wikiLayoutOptions,
+} from "../../views/view-options.ts";
 
 interface NoteRenderInput {
 	ctx: WikiRequestContext;
@@ -17,6 +21,8 @@ noteTitle: string;
 	content: string;
 	sidebarNotes: { slug: string; title: string }[];
 	ogTitle?: string;
+	// The record this URL is the page for — the note, or the wiki on its home page.
+	canonicalRecord: { at_uri: string; did: string };
 }
 
 export function renderNoteResponse(input: NoteRenderInput): Response {
@@ -56,6 +62,7 @@ ogTitle: input.ogTitle ?? `${noteTitle} - ${ctx.wiki.name}`,
 				ogUrl: canonicalUrl,
 				ogImage,
 				...ogDescription,
+				...atCanonicalOption(ctx.wiki, input.canonicalRecord),
 			},
 			ctx.wiki.language,
 		),
diff --git a/src/server/routes/wiki.ts b/src/server/routes/wiki.ts
--- a/src/server/routes/wiki.ts
+++ b/src/server/routes/wiki.ts
@@ -37,6 +37,7 @@ import { editSidebarPage } from "../../views/edit-sidebar.ts";
 import { newWikiPage } from "../../views/new-wiki.ts";
 import { settingsPage } from "../../views/settings.ts";
 import {
+	atCanonicalOption,
 	baseLayoutOptions,
 	wikiIdentity,
 	wikiLayoutOptions,
@@ -402,6 +403,8 @@ noteTitle: homeData.note.title,
 				content: homeData.current.content,
 				sidebarNotes,
 				ogTitle: ctx.wiki.name,
+				// This URL is the wiki's page; the home note has its own.
+				canonicalRecord: ctx.wiki,
 			});
 		}
 
@@ -418,6 +421,7 @@ ogTitle: ctx.wiki.name,
 					ogUrl: `${publicUrl}${wikiUrl(handle, ctx.wiki.slug)}`,
 					ogImage,
 					...ogDescription,
+					...atCanonicalOption(ctx.wiki, ctx.wiki),
 				},
 				ctx.wiki.language,
 			),
diff --git a/src/views/layout.ts b/src/views/layout.ts
--- a/src/views/layout.ts
+++ b/src/views/layout.ts
@@ -70,6 +70,8 @@ ogTitle?: string;
 	ogUrl?: string;
 	ogDescription?: string;
 	ogImage?: string;
+	// AT Tags: the record this URL is the page for. Set only for public wikis.
+	atCanonical?: { uri: string; authorDid: string };
 	wikiThemeMode?: WikiThemeMode;
 	wikiTheme?: ThemeName;
 	enableSearchShortcut?: boolean;
@@ -106,6 +108,17 @@ <meta name="twitter:card" content="summary_large_image">
   <meta name="twitter:title" content="${escapeHtml(ogTitle)}">
   <meta name="twitter:description" content="${escapeHtml(ogDescription)}">
   <meta name="twitter:image" content="${escapeHtml(ogImage)}">`;
+}
+
+// https://tangled.org/chrisshank.com/at-tags/ — the inverse of /at/:did/:collection/:rkey:
+// tells any atmosphere tool which record this page renders.
+function renderAtTags(options: LayoutOptions | undefined): string {
+	const record = options?.atCanonical;
+	if (!record) return "";
+	const uri = escapeHtml(record.uri);
+	return `<meta name="at:canonical" content="${uri}">
+  <meta name="at:author" content="at://${escapeHtml(record.authorDid)}">
+  <link rel="alternate" href="${uri}">`;
 }
 
 function renderSearchButton(locale: Locale = "en"): string {
@@ -328,6 +341,7 @@ ${options?.noindex ? `<meta name="robots" content="noindex,nofollow">` : ""}
   <link rel="preconnect" href="https://cdn.bsky.app" crossorigin>
   ${options?.csrfToken ? `<meta name="csrf-token" content="${escapeHtml(options.csrfToken)}">` : ""}
   ${renderOpenGraph(options, title)}
+  ${renderAtTags(options)}
   <link rel="stylesheet" href="${assetUrl("/public/dist.css")}">
   <style>${themeRootStyle(userTheme)}
     .sidebar-md a { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--text-secondary); }
diff --git a/src/views/view-options.ts b/src/views/view-options.ts
--- a/src/views/view-options.ts
+++ b/src/views/view-options.ts
@@ -1,5 +1,6 @@
 import type { RequestContext, WikiRequestContext } from "../lib/access.ts";
 import type { WikiIdentity } from "../lib/wiki-identity.ts";
+import type { WikiRow } from "../server/db/types.ts";
 
 // The layout fields every page derives from the request context.
 export function baseLayoutOptions(ctx: RequestContext) {
@@ -29,3 +30,13 @@ wikiThemeMode: ctx.wiki.theme_mode,
 		wikiTheme: ctx.wiki.theme,
 	};
 }
+
+/** Spread into layout options. AT Tags invite third-party resolvers to a page,
+ * which is meaningless for a wiki nobody else can open — hence public only. */
+export function atCanonicalOption(
+	wiki: WikiRow,
+	record: { at_uri: string; did: string },
+) {
+	if (wiki.visibility !== "public") return {};
+	return { atCanonical: { uri: record.at_uri, authorDid: record.did } };
+}
diff --git a/tests/views/at-tags.test.ts b/tests/views/at-tags.test.ts
new file mode 100644
--- /dev/null
+++ b/tests/views/at-tags.test.ts
@@ -0,0 +1,110 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { cleanupWikiAndDependents } from "../helpers/cleanup.ts";
+import {
+	ALICE,
+	BOB,
+	createDiff,
+	emitMembership,
+	emitNote,
+	emitRevision,
+	emitWiki,
+} from "../integration/helpers.ts";
+import { fetch, loginCookie } from "../integration/http-helpers.ts";
+
+const SLUG = "at-tags-wiki";
+const PRIVATE_SLUG = "at-tags-private";
+
+const WIKI_URI = emitWiki(ALICE.did, "AT Tags Wiki", "public", SLUG).uri;
+const NOTE_URI = emitNote(ALICE.did, "home", "Home", WIKI_URI).uri;
+emitRevision(ALICE.did, NOTE_URI, createDiff("", "# Home\n"));
+
+function metaContent(html: string, name: string): string | null {
+	const match = html.match(
+		new RegExp(`<meta name="${name}" content="([^"]*)">`),
+	);
+	return match?.[1] ?? null;
+}
+
+// Owner refs depend on whichever profile stub another test file installed, so
+// follow the redirect chain rather than asserting a Location.
+async function follow(path: string): Promise<Response> {
+	let res = await fetch("GET", path);
+	for (let hop = 0; hop < 3 && res.status >= 300 && res.status < 400; hop++) {
+		const next = res.headers.get("location");
+		if (!next) break;
+		res = await fetch("GET", next);
+	}
+	return res;
+}
+
+afterAll(() => {
+	cleanupWikiAndDependents(SLUG);
+	cleanupWikiAndDependents(PRIVATE_SLUG);
+});
+
+describe("AT Tags", () => {
+	test("a note page points at the note record", async () => {
+		const res = await fetch("GET", `/@${ALICE.handle}/${SLUG}/home`);
+		const html = await res.text();
+		expect(metaContent(html, "at:canonical")).toBe(NOTE_URI);
+		expect(metaContent(html, "at:author")).toBe(`at://${ALICE.did}`);
+		expect(html).toContain(`<link rel="alternate" href="${NOTE_URI}">`);
+	});
+
+	test("the wiki home points at the wiki record, not the home note", async () => {
+		const res = await fetch("GET", `/@${ALICE.handle}/${SLUG}`);
+		const html = await res.text();
+		expect(metaContent(html, "at:canonical")).toBe(WIKI_URI);
+		expect(metaContent(html, "at:canonical")).not.toBe(NOTE_URI);
+	});
+
+	test("at:author is the record's author, not the wiki owner", async () => {
+		emitMembership(ALICE.did, BOB.did, WIKI_URI, "contributor");
+		const bobNote = emitNote(BOB.did, "bob-note", "Bob Note", WIKI_URI).uri;
+		emitRevision(BOB.did, bobNote, createDiff("", "by bob\n"));
+
+		const res = await fetch("GET", `/@${ALICE.handle}/${SLUG}/bob-note`);
+		const html = await res.text();
+		expect(metaContent(html, "at:canonical")).toBe(bobNote);
+		expect(metaContent(html, "at:author")).toBe(`at://${BOB.did}`);
+	});
+
+	test("at:canonical resolves back to the page that emitted it", async () => {
+		const html = await (
+			await fetch("GET", `/@${ALICE.handle}/${SLUG}/home`)
+		).text();
+		const uri = metaContent(html, "at:canonical") ?? "";
+
+		const res = await follow(`/at/${uri.slice("at://".length)}`);
+		expect(res.status).toBe(200);
+		expect(metaContent(await res.text(), "at:canonical")).toBe(uri);
+	});
+
+	test("a private wiki emits no AT Tags, even for the owner", async () => {
+		const privateUri = emitWiki(
+			ALICE.did,
+			"Private",
+			"private",
+			PRIVATE_SLUG,
+		).uri;
+		const privateNote = emitNote(ALICE.did, "secret", "Secret", privateUri).uri;
+		emitRevision(ALICE.did, privateNote, createDiff("", "shh\n"));
+		const cookie = await loginCookie(ALICE.handle);
+
+		const notePage = await fetch(
+			"GET",
+			`/@${ALICE.handle}/${PRIVATE_SLUG}/secret`,
+			{
+				cookie,
+			},
+		);
+		expect(notePage.status).toBe(200);
+		expect(await notePage.text()).not.toContain("at:canonical");
+
+		const wikiPage = await fetch("GET", `/@${ALICE.handle}/${PRIVATE_SLUG}`, {
+			cookie,
+		});
+		expect(wikiPage.status).toBe(200);
+		expect(await wikiPage.text()).not.toContain("at:canonical");
+	});
+});