diff --git a/docs/spec/runtime/api.md b/docs/spec/runtime/api.md
index 0c49cb3e..0d67edb5 100644
--- a/docs/spec/runtime/api.md
+++ b/docs/spec/runtime/api.md
@@ -133,6 +133,8 @@ POST   …/skills/{slug}/install              install a registry/company skill
 POST   …/skills/{slug}/uninstall            uninstall a skill
 PUT    …/skills/{slug}                       enable / disable a skill
 POST   …/team                               add an operator-overlay teammate
+GET    …/team/{agentId}                      one agent in full (tier, tools, desks)
+PATCH  …/team/{agentId}                      edit an overlay teammate
 DELETE …/team/{agentId}                      remove an overlay teammate
 PUT    …/team/{agentId}/inbox                toggle a teammate's inbox
 PUT    …/team/{agentId}/budget               set / change / remove a daily cap
@@ -168,8 +170,44 @@ note.
 
 Team writes are an **operator overlay** persisted through the store, merged
 into the manifest roster at read time — the version-controlled `company.toml`
-is never rewritten. In v1 overlay teammates are **roster-only**: they appear in
-the roster and get an inbox, but no harness `Agent` is built for them yet.
+is never rewritten. Overlay teammates are addressable: since issue #71 the
+harness builds a real agent for each one, with the company-wide tool grant, no
+cognition tier, and never the orchestrator.
+
+`GET …/team/{agentId}` is the **agent detail** read (issue #264). `GET …/team`
+answers "who is on the roster"; this answers "what is this agent", and before it
+existed neither the console nor any other client could reach an agent's tier,
+its tool grants or its desk membership — the roster row carried none of them, so
+checking what a company actually grants an agent was not possible from outside
+the process.
+
+The `tools` object is the reason the route earns its keep. It carries three
+lists, because only the third is the answer:
+
+| field | meaning |
+|---|---|
+| `requested` | the agent's own `[[agent]].tools` globs. **Empty means the company's standard grant**, not "no tools" |
+| `companyAllow` | the `[tools].allow` ceiling the request is intersected with |
+| `effective` | what the agent actually holds |
+
+`effective` is computed by the same `agent_effective_grants` the harness calls
+when it builds the agent, so the readout cannot drift from what is enforced.
+`isOrchestrator` is likewise resolved by the roster rule (a `tier =
+"orchestrator"` agent, else the first declared) rather than read off `tier`, so
+a company that tags nobody still names its orchestrator.
+
+`PATCH …/team/{agentId}` edits an **overlay** teammate's `name`, `role` and
+`description`. It is a patch: an omitted key is left alone, and `"description":
+null` clears it — the two must stay apart or every partial save would erase an
+agent's instructions. A blank `name`/`role` is `400`, an unknown teammate `404`,
+and a **manifest** teammate is `409`: its fields live in the version-controlled
+`company.toml`, and the console does not rewrite the blueprint. The one thing
+that *is* changeable on such a teammate is its daily budget, and that works
+because #343 modelled it as an override rather than as a rewrite. Every detail
+response carries an `editable` list naming the fields this route will accept, so
+a client renders read-only from the host's answer instead of re-deriving the
+rule. `tier` and `tools` are read-only for both kinds: there is no override
+layer for either, and adding one is a policy decision rather than a form field.
 
 The two **budget** routes (issue #343) are how a teammate's `budget_usd_daily`
 becomes changeable without a redeploy. Both are **admin-only** — a member gets
diff --git a/frontend/src/api/client.ts b/frontend/src/api/client.ts
index 643b6c4a..14346517 100644
--- a/frontend/src/api/client.ts
+++ b/frontend/src/api/client.ts
@@ -8,6 +8,7 @@
 
 import type { ConsoleConfig } from "../config";
 import {
+  type AgentDetailDto,
   ApiError,
   type ApiErrorBody,
   type AppSpec,
@@ -20,6 +21,7 @@ import {
   type ConnectionState,
   type CreateDeskInput,
   type DeskDto,
+  type EditAgentInput,
   type FeedbackInput,
   type FeedbackResponse,
   type FeedbackSummary,
@@ -459,6 +461,50 @@ export class OpenCompanyClient {
     return this.request<TeamMemberDto>("POST", `${this.scope(company)}/team`, input);
   }
 
+  /**
+   * One agent in full (issue #264): identity, tier, **resolved** tool grants and
+   * desk membership.
+   *
+   * Not derivable from `listTeam`, and that is the point — the roster row
+   * carries none of it, and the tool grants had no read surface anywhere before
+   * this route, so what a company actually grants an agent could not be checked
+   * from outside the process.
+   *
+   * Hosts predating the route 404; callers should treat that as "this host
+   * can't open an agent yet" rather than as a missing teammate.
+   */
+  getAgent(agentId: string, company?: string | null): Promise<AgentDetailDto> {
+    return this.request<AgentDetailDto>(
+      "GET",
+      `${this.scope(company)}/team/${encodeURIComponent(agentId)}`,
+    );
+  }
+
+  /**
+   * Edit an agent, and get the whole agent back (issue #264).
+   *
+   * A patch: keys absent from `input` are left alone, so a caller that renders
+   * some of an agent's fields cannot blank the rest by omission. `description:
+   * null` clears the instructions and `description: undefined` leaves them,
+   * which is why the two must not be collapsed on the way in.
+   *
+   * The host refuses a manifest teammate with a 409 — its fields live in the
+   * version-controlled `company.toml`, and the console does not rewrite that.
+   * Ask `getAgent` first: its `editable` list is the host's own statement of
+   * which fields this call will accept.
+   */
+  updateAgent(
+    agentId: string,
+    input: EditAgentInput,
+    company?: string | null,
+  ): Promise<AgentDetailDto> {
+    return this.request<AgentDetailDto>(
+      "PATCH",
+      `${this.scope(company)}/team/${encodeURIComponent(agentId)}`,
+      input,
+    );
+  }
+
   /**
    * Set, change, or remove a teammate's daily spend cap (issue #343). Admin-only
    * on the host — a member gets 403 — and the change is enforced on the
diff --git a/frontend/src/api/types.ts b/frontend/src/api/types.ts
index 8df104e3..1a884d5f 100644
--- a/frontend/src/api/types.ts
+++ b/frontend/src/api/types.ts
@@ -512,6 +512,97 @@ export interface TeamMemberDto {
   budgetSetAtMillis?: number;
 }
 
+/**
+ * One agent in full, from `GET .../team/{agentId}` (issue #264).
+ *
+ * `GET .../team` answers "who is on the roster"; this answers "what is this
+ * agent". Everything below the identity block was unreachable from the console
+ * before this route existed, and the tool grants were unreachable from
+ * *anywhere* — which is why a change to what a company grants its agents could
+ * not be checked from outside the process.
+ */
+export interface AgentDetailDto {
+  id: string;
+  /** Absent for a manifest teammate, which is named by its role. */
+  name?: string;
+  role: string;
+  /**
+   * What the agent was defined with. This text frames the agent's persona on
+   * every turn, so it is the closest thing the company has to an `AGENT.md`.
+   */
+  description?: string;
+  /**
+   * Which half of the roster this teammate comes from, and therefore what may
+   * be done to it. `manifest` teammates are declared in the version-controlled
+   * `company.toml`; `overlay` teammates were added at runtime and live on the
+   * company record this host writes.
+   */
+  source: "manifest" | "overlay";
+  /**
+   * The field names the host will accept in a `PATCH`. **The console renders a
+   * field read-only exactly when this list omits it** rather than deciding for
+   * itself — a client-side copy of the rule would eventually disagree with the
+   * host, and the operator would meet the disagreement as a failed save.
+   */
+  editable: string[];
+  /** The declared cognition-tier hint, when the manifest sets one. */
+  tier?: string;
+  /**
+   * Whether this teammate is the company's orchestrator. Resolved by the roster
+   * rule (a tagged tier first, else the first declared agent), so it is NOT the
+   * same question as `tier === "orchestrator"`: a company that tags nobody still
+   * has one.
+   */
+  isOrchestrator: boolean;
+  tools: AgentToolsDto;
+  desks: AgentDeskDto[];
+  inboxEnabled: boolean;
+  /** The cap in force and its attribution; same absent-means-uncapped contract as `TeamMemberDto`. */
+  budgetUsdDaily?: number;
+  spentTodayUsd?: number;
+  budgetSetBy?: string;
+  budgetSetAtMillis?: number;
+}
+
+/**
+ * An agent's tool grants at all three levels.
+ *
+ * The distinction is the point: `requested` is what the agent's own `tools`
+ * line asks for, `companyAllow` is the ceiling it is intersected with, and
+ * `effective` is what the agent actually holds. An **empty `requested` means
+ * the company's standard grant**, not "no tools", so a surface that renders the
+ * request alone reports the opposite of the truth for exactly those agents.
+ */
+export interface AgentToolsDto {
+  requested: string[];
+  companyAllow: string[];
+  effective: string[];
+}
+
+/** A desk this agent sits on, and whether it leads it. */
+export interface AgentDeskDto {
+  id: string;
+  name: string;
+  /** The desk's first effective member, who receives a `delegate_to_desk` hand-off. */
+  lead: boolean;
+}
+
+/**
+ * The body of `PATCH .../team/{agentId}` (issue #264).
+ *
+ * A patch, not a replacement: an omitted key leaves that field alone. That is
+ * why `description` is `string | null | undefined` and the three are all
+ * different — `undefined` leaves the instructions be, `null` clears them, and a
+ * string sets them. Building this object with a spread that drops `undefined`
+ * is correct; one that turns `undefined` into `null` would erase an agent's
+ * instructions on every partial save.
+ */
+export interface EditAgentInput {
+  name?: string;
+  role?: string;
+  description?: string | null;
+}
+
 /**
  * The body of `PUT .../team/{id}/budget`.
  *
diff --git a/frontend/src/components/app-shell.tsx b/frontend/src/components/app-shell.tsx
index b1a4cacf..c0a98c18 100644
--- a/frontend/src/components/app-shell.tsx
+++ b/frontend/src/components/app-shell.tsx
@@ -1016,7 +1016,18 @@ export function AppShell({
               }}
             />
           )}
-          {view === "team" && <TeamView client={client} company={company} />}
+          {view === "team" && (
+            <TeamView
+              client={client}
+              company={company}
+              // `#/team/<agentId>` opens that agent (issue #264). The sub-page
+              // comes back unvalidated, as `useHashView` documents: only this
+              // view knows which ids exist, and the detail screen resolves an
+              // unknown one against the host rather than guessing here.
+              sub={sub}
+              onOpenAgent={(agentId) => navigate("team", agentId ?? undefined)}
+            />
+          )}
           {view === "memory" && <MemoryView client={client} company={company} />}
           {view === "workspace" && (
             <Suspense
diff --git a/frontend/src/lib/agent.ts b/frontend/src/lib/agent.ts
new file mode 100644
index 00000000..3cd12371
--- /dev/null
+++ b/frontend/src/lib/agent.ts
@@ -0,0 +1,151 @@
+// One agent, read and edited (issue #264). The pure half of the detail view:
+// the field definitions both the create dialog and the edit form render from,
+// and the three derivations that are easy to get quietly wrong.
+
+import type { AgentDetailDto, AgentToolsDto, EditAgentInput } from "@/api/types";
+
+/** The fields that describe an agent, in the order both forms show them. */
+export type AgentFieldKey = "name" | "role" | "description";
+
+export interface AgentFieldSpec {
+  key: AgentFieldKey;
+  label: string;
+  placeholder: string;
+  /** `prose` renders a textarea; `line` renders a single-line input. */
+  kind: "line" | "prose";
+}
+
+/**
+ * The single definition of an agent's authored fields.
+ *
+ * Shared deliberately by "Define an agent" and the detail view's edit form: the
+ * two collect the same three things, and before this they would have collected
+ * them under two sets of labels and placeholders that drifted apart. The host
+ * accepts exactly these keys in a `PATCH`, so the list is also the client half
+ * of that contract.
+ */
+export const AGENT_FIELDS: AgentFieldSpec[] = [
+  { key: "name", label: "Name", placeholder: "e.g. Nova", kind: "line" },
+  { key: "role", label: "Role", placeholder: "e.g. Growth Marketer", kind: "line" },
+  {
+    key: "description",
+    label: "What they do",
+    placeholder: "e.g. Runs paid acquisition and reports on ROAS.",
+    kind: "prose",
+  },
+];
+
+/** The three authored values, as a form holds them. */
+export type AgentDraft = Record<AgentFieldKey, string>;
+
+/** A blank draft, for the create form and for a detail view that has not loaded. */
+export function emptyDraft(): AgentDraft {
+  return { name: "", role: "", description: "" };
+}
+
+/** The draft a detail response starts an edit from. */
+export function draftFrom(detail: AgentDetailDto): AgentDraft {
+  return {
+    // A manifest teammate carries no name of its own and is shown by its role,
+    // so the form starts from the same thing the card does.
+    name: detail.name ?? "",
+    role: detail.role,
+    description: detail.description ?? "",
+  };
+}
+
+/**
+ * Whether the host will accept an edit to this field.
+ *
+ * Read from the host's own `editable` list rather than inferred from `source`.
+ * The two agree today, and the moment they stop agreeing the host is right:
+ * duplicating the rule here is how a console starts offering a field that saves
+ * with a 409.
+ */
+export function isEditable(detail: AgentDetailDto, key: AgentFieldKey): boolean {
+  return detail.editable.includes(key);
+}
+
+/**
+ * The `PATCH` body for a draft, or `null` when nothing changed.
+ *
+ * Two rules, and both matter:
+ *
+ * - **Only changed, editable fields are sent.** An unchanged field is left out
+ *   entirely, so a form that renders a read-only field cannot echo it back and
+ *   have the host refuse the whole save.
+ * - **A cleared description is `null`, not `""`.** `undefined` means "leave the
+ *   instructions alone" on the wire; sending `undefined` for a field the
+ *   operator deliberately emptied would silently keep the old text, and the
+ *   operator would watch their deletion come back.
+ */
+export function agentEdits(detail: AgentDetailDto, draft: AgentDraft): EditAgentInput | null {
+  const current = draftFrom(detail);
+  const edits: EditAgentInput = {};
+  let changed = false;
+
+  for (const field of AGENT_FIELDS) {
+    if (!isEditable(detail, field.key)) continue;
+    const next = draft[field.key].trim();
+    if (next === current[field.key].trim()) continue;
+    changed = true;
+    if (field.key === "description") {
+      edits.description = next === "" ? null : next;
+    } else if (field.key === "name") {
+      edits.name = next;
+    } else {
+      edits.role = next;
+    }
+  }
+
+  return changed ? edits : null;
+}
+
+/** Whether a draft could be saved at all: name and role are required. */
+export function draftIsValid(detail: AgentDetailDto, draft: AgentDraft): boolean {
+  return AGENT_FIELDS.every(
+    (field) =>
+      field.kind !== "line" || !isEditable(detail, field.key) || draft[field.key].trim() !== "",
+  );
+}
+
+/** What an agent's tool grants amount to, once the intersection is applied. */
+export interface ToolGrantSummary {
+  /** What the agent actually holds. */
+  effective: string[];
+  /**
+   * Globs the agent asked for that the company's allow-list does not cover, so
+   * they are not grants however plainly the manifest lists them. This is the
+   * line an operator checking a tool change is looking for.
+   */
+  dropped: string[];
+  /**
+   * Whether the agent lists no tools of its own and therefore inherits the
+   * company's whole allow-list.
+   *
+   * The case worth naming: an empty `requested` reads like "no tools" and means
+   * the opposite. A screen that showed an empty list here would tell an
+   * operator their agent is powerless when it holds everything the company
+   * allows.
+   */
+  standardGrant: boolean;
+}
+
+export function summarizeGrants(tools: AgentToolsDto): ToolGrantSummary {
+  return {
+    effective: tools.effective,
+    dropped: tools.requested.filter((glob) => !tools.effective.includes(glob)),
+    standardGrant: tools.requested.length === 0,
+  };
+}
+
+/**
+ * How an agent's tier reads on screen.
+ *
+ * `isOrchestrator` rather than `tier === "orchestrator"`: a company that tags
+ * nobody still has an orchestrator (the first agent declared), and the host has
+ * already resolved which one it is.
+ */
+export function tierLabel(detail: AgentDetailDto): string {
+  return detail.isOrchestrator ? "Orchestrator" : "Worker";
+}
diff --git a/frontend/src/views/TeamView.tsx b/frontend/src/views/TeamView.tsx
index af3b0181..8aa9d5ef 100644
--- a/frontend/src/views/TeamView.tsx
+++ b/frontend/src/views/TeamView.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { Mail, MoreHorizontal, Plus, Sparkles, UserPlus, Wallet } from "lucide-react";
 import { toast } from "sonner";
 
@@ -28,7 +28,7 @@ import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Skeleton } from "@/components/ui/skeleton";
 import { Switch } from "@/components/ui/switch";
-import { Textarea } from "@/components/ui/textarea";
+import { emptyDraft, type AgentDraft, type AgentFieldKey } from "@/lib/agent";
 import {
   fromDto,
   initials,
@@ -38,16 +38,26 @@ import {
   type TeamMember,
 } from "@/lib/team";
 import { cn } from "@/lib/utils";
+import { AgentDetailView } from "@/views/team/AgentDetailView";
+import { AgentFields } from "@/views/team/AgentFields";
 
 interface Props {
   client: OpenCompanyClient;
   company: string | null;
+  /**
+   * The agent id in the hash (`#/team/<agentId>`), when one is addressed. The
+   * detail view is a sub-page rather than a modal so an operator can link to an
+   * agent, refresh onto it, and use Back (issue #264).
+   */
+  sub: string | null;
+  /** Open an agent, or return to the roster with `null`. */
+  onOpenAgent: (agentId: string | null) => void;
 }
 
 type Load = "loading" | "ready";
 
 /** The company's agents — showcased and operator-definable. */
-export function TeamView({ client, company }: Props) {
+export function TeamView({ client, company, sub, onOpenAgent }: Props) {
   const [load, setLoad] = useState<Load>("loading");
   const [fromHost, setFromHost] = useState(false);
   const [members, setMembers] = useState<TeamMember[]>([]);
@@ -143,6 +153,34 @@ export function TeamView({ client, company }: Props) {
     void loadViewer();
   }, [boot, loadViewer]);
 
+  /**
+   * Re-read the roster on the way back from the agent sub-page (issue #264).
+   *
+   * This view renders the detail as an early return, so opening an agent never
+   * unmounts the roster and never re-runs `boot`. An edit saved in the panel
+   * therefore landed on the host while these cards went on showing what they
+   * held before it: press Back after renaming an agent and the old role is
+   * still on the card, until a hard reload. The panel and the roster disagreed
+   * about the same company, and the roster was the wrong one.
+   *
+   * Keyed on `sub` rather than on the Back button's callback, so the browser's
+   * own Back — and a hand-edited hash — refresh too. The ref is what keeps the
+   * first mount from fetching twice: the effect above already did.
+   */
+  const leftAgentPage = useRef(false);
+  useEffect(() => {
+    if (sub) {
+      leftAgentPage.current = true;
+      return;
+    }
+    if (!leftAgentPage.current) return;
+    leftAgentPage.current = false;
+    // Deliberately without `setLoad("loading")`: the cards on screen are the
+    // right cards, only possibly stale, so they stay put until the new ones
+    // land rather than blanking to a skeleton on every Back.
+    void boot();
+  }, [sub, boot]);
+
   /** A human label for whoever set a cap — never a raw user id. */
   function whoSet(userId: string): string {
     const person = people.find((p) => p.id === userId);
@@ -238,6 +276,20 @@ export function TeamView({ client, company }: Props) {
     }
   }
 
+  // `#/team/<agentId>` is the agent detail sub-page. Every hook above has
+  // already run, so this early return keeps hook order stable across both
+  // shapes of the view.
+  if (sub) {
+    return (
+      <AgentDetailView
+        client={client}
+        company={company}
+        agentId={sub}
+        onBack={() => onOpenAgent(null)}
+      />
+    );
+  }
+
   return (
     <div className="flex-1 overflow-y-auto">
       <div className="mx-auto w-full max-w-5xl space-y-6 px-4 py-6">
@@ -268,6 +320,11 @@ export function TeamView({ client, company }: Props) {
                 inboxOn={m.inboxEnabled}
                 onToggleInbox={() => void toggleMemberInbox(m)}
                 onRemove={() => void removeMember(m)}
+                // Only a host-backed teammate can be opened: a starter-team
+                // card is a local placeholder with no record behind it, so its
+                // id would 404 and the detail view would report a teammate that
+                // was never removed.
+                onOpen={fromHost ? () => onOpenAgent(m.id) : undefined}
                 // Budget edits need a teammate the host actually knows about;
                 // starter-team cards are local placeholders with no record.
                 canEditBudget={isAdmin && fromHost}
@@ -339,6 +396,7 @@ function MemberCard({
   inboxOn,
   onToggleInbox,
   onRemove,
+  onOpen,
   canEditBudget,
   onEditBudget,
   onRemoveCap,
@@ -349,6 +407,8 @@ function MemberCard({
   inboxOn: boolean;
   onToggleInbox: () => void;
   onRemove: () => void;
+  /** Open this agent's detail page. Undefined when the card has no host record. */
+  onOpen?: () => void;
   /** Whether to offer the budget controls at all (admins, host-backed cards). */
   canEditBudget: boolean;
   onEditBudget: () => void;
@@ -374,10 +434,25 @@ function MemberCard({
           >
             {initials(member.name)}
           </div>
-          <div className="min-w-0 flex-1">
-            <p className="truncate font-medium">{member.name}</p>
-            <p className="truncate text-xs text-muted-foreground">{member.role}</p>
-          </div>
+          {onOpen ? (
+            // The card's own name is the way in (issue #264). A whole-card
+            // click would swallow the inbox switch and the actions menu, both
+            // of which live inside it, so the target is deliberately this
+            // block rather than the card.
+            <button
+              onClick={onOpen}
+              className="min-w-0 flex-1 rounded-md text-left transition-colors hover:text-primary focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+              data-testid="team-card-open"
+            >
+              <p className="truncate font-medium">{member.name}</p>
+              <p className="truncate text-xs text-muted-foreground">{member.role}</p>
+            </button>
+          ) : (
+            <div className="min-w-0 flex-1">
+              <p className="truncate font-medium">{member.name}</p>
+              <p className="truncate text-xs text-muted-foreground">{member.role}</p>
+            </div>
+          )}
           <DropdownMenu>
             <DropdownMenuTrigger
               render={<Button variant="ghost" size="icon" className="-mr-1 -mt-1 size-7" aria-label="Member actions" />}
@@ -385,6 +460,14 @@ function MemberCard({
               <MoreHorizontal className="size-4" />
             </DropdownMenuTrigger>
             <DropdownMenuContent align="end">
+              {onOpen && (
+                <>
+                  <DropdownMenuItem onClick={onOpen} data-testid="team-open-agent">
+                    View agent
+                  </DropdownMenuItem>
+                  <DropdownMenuSeparator />
+                </>
+              )}
               {canEditBudget && (
                 <>
                   <DropdownMenuItem onClick={onEditBudget} data-testid="team-budget-edit">
@@ -563,16 +646,15 @@ function AddMemberDialog({
   /** Whether to offer the cap field — setting one is admin-only on the host. */
   canSetBudget: boolean;
 }) {
-  const [name, setName] = useState("");
-  const [role, setRole] = useState("");
-  const [description, setDescription] = useState("");
+  // The same three authored fields the detail view edits, held in the same
+  // shape (issue #264) so "Define an agent" and "Edit agent" cannot drift into
+  // two different sets of labels for one set of values.
+  const [draft, setDraft] = useState<AgentDraft>(emptyDraft);
   const [inbox, setInbox] = useState(false);
   const [budget, setBudget] = useState("");
 
   function reset() {
-    setName("");
-    setRole("");
-    setDescription("");
+    setDraft(emptyDraft());
     setInbox(false);
     setBudget("");
   }
@@ -587,8 +669,14 @@ function AddMemberDialog({
   const budgetInvalid = budget.trim() !== "" && budgetUsdDaily === undefined;
 
   function submit() {
-    if (!name.trim() || !role.trim() || budgetInvalid) return;
-    onAdd({ name, role, description, inbox, budgetUsdDaily });
+    if (!draft.name.trim() || !draft.role.trim() || budgetInvalid) return;
+    onAdd({
+      name: draft.name,
+      role: draft.role,
+      description: draft.description,
+      inbox,
+      budgetUsdDaily,
+    });
     reset();
   }
 
@@ -605,34 +693,11 @@ function AddMemberDialog({
           <DialogTitle>Define an agent</DialogTitle>
           <DialogDescription>Add a teammate to your company&apos;s roster.</DialogDescription>
         </DialogHeader>
-        <div className="grid gap-2">
-          <Label htmlFor="member-name">Name</Label>
-          <Input
-            id="member-name"
-            value={name}
-            onChange={(e) => setName(e.target.value)}
-            placeholder="e.g. Nova"
-          />
-        </div>
-        <div className="grid gap-2">
-          <Label htmlFor="member-role">Role</Label>
-          <Input
-            id="member-role"
-            value={role}
-            onChange={(e) => setRole(e.target.value)}
-            placeholder="e.g. Growth Marketer"
-          />
-        </div>
-        <div className="grid gap-2">
-          <Label htmlFor="member-desc">What they do</Label>
-          <Textarea
-            id="member-desc"
-            rows={3}
-            value={description}
-            onChange={(e) => setDescription(e.target.value)}
-            placeholder="e.g. Runs paid acquisition and reports on ROAS."
-          />
-        </div>
+        <AgentFields
+          idPrefix="member"
+          draft={draft}
+          onChange={(key: AgentFieldKey, value) => setDraft((d) => ({ ...d, [key]: value }))}
+        />
         {canSetBudget && (
           <div className="grid gap-2">
             <Label htmlFor="member-budget-new">Daily budget (optional)</Label>
@@ -659,7 +724,10 @@ function AddMemberDialog({
           <Button variant="ghost" onClick={() => onOpenChange(false)}>
             Cancel
           </Button>
-          <Button onClick={submit} disabled={!name.trim() || !role.trim() || budgetInvalid}>
+          <Button
+            onClick={submit}
+            disabled={!draft.name.trim() || !draft.role.trim() || budgetInvalid}
+          >
             Add member
           </Button>
         </DialogFooter>
diff --git a/frontend/src/views/team/AgentDetailView.tsx b/frontend/src/views/team/AgentDetailView.tsx
new file mode 100644
index 00000000..157a2284
--- /dev/null
+++ b/frontend/src/views/team/AgentDetailView.tsx
@@ -0,0 +1,421 @@
+import { useCallback, useEffect, useState, type ReactNode } from "react";
+import { ArrowLeft, Mail, Pencil, Sparkles, Users, Wrench } from "lucide-react";
+import { toast } from "sonner";
+
+import type { OpenCompanyClient } from "@/api/client";
+import { ApiError, type AgentDetailDto } from "@/api/types";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent } from "@/components/ui/card";
+import { Skeleton } from "@/components/ui/skeleton";
+import {
+  agentEdits,
+  draftFrom,
+  draftIsValid,
+  isEditable,
+  summarizeGrants,
+  tierLabel,
+  type AgentDraft,
+  type AgentFieldKey,
+} from "@/lib/agent";
+import { initials, TEAM_TONES, toneFor } from "@/lib/team";
+import { cn } from "@/lib/utils";
+import { AgentFields } from "@/views/team/AgentFields";
+
+type Load = "loading" | "ready" | "missing" | "unsupported" | "error";
+
+/**
+ * Why a detail read failed, in the operator's terms rather than the wire's.
+ *
+ * A `404` from `GET …/team/{agentId}` is **two different facts**, and the status
+ * cannot tell them apart: a host that predates this route 404s the path it does
+ * not serve, and a host that serves it 404s a teammate that is gone. Saying "no
+ * such teammate" to the first sends an operator looking for a deletion that
+ * never happened; saying "this host is too old" to the second hides a real
+ * removal behind a version complaint.
+ *
+ * The roster settles it, but only if the right question is asked. "Did `GET
+ * …/team` answer?" is not enough — the roster route is the *older* one, so an
+ * out-of-date host answers it perfectly. The question that separates the two is
+ * whether the roster still **contains this agent**:
+ *
+ * | `GET …/team` | outcome |
+ * |---|---|
+ * | lists this agent | the host has the roster but not the detail route → `unsupported` |
+ * | omits this agent | the host serves both and the teammate is gone → `missing` |
+ * | fails too | nothing is reachable; do not guess → `error` |
+ *
+ * Anything that is not a `404` — a transport failure, a `500` — is `error`. It
+ * used to fall into `unsupported`, which told an operator their host was too old
+ * when their network had simply dropped.
+ */
+async function classifyFailure(
+  error: unknown,
+  roster: () => Promise<{ id: string }[]>,
+  agentId: string,
+): Promise<Exclude<Load, "loading" | "ready">> {
+  if (!(error instanceof ApiError) || error.status !== 404) return "error";
+  const members = await roster().catch(() => null);
+  if (members === null) return "error";
+  return members.some((member) => member.id === agentId) ? "unsupported" : "missing";
+}
+
+/**
+ * One agent, opened (issue #264).
+ *
+ * Before this the Team card was a dead end: a name, a role, and a destructive
+ * Remove. None of what an agent *is* was reachable once it existed, so an
+ * operator could not read the instructions it was defined with, could not see
+ * which tools it may use or which desks it belongs to, and could not change any
+ * of it. This is the screen that answers those questions, and edits the ones
+ * the host says are editable.
+ *
+ * ## Read-only is a fact about the agent, not a state of this screen
+ *
+ * A **manifest** teammate is declared in the company's version-controlled
+ * `company.toml`. Its fields are shown read-only, with the reason next to them:
+ * the console does not rewrite the blueprint, so the edit belongs in the file.
+ * An **overlay** teammate was added here and is edited here.
+ *
+ * Which is which comes from the host's own `editable` list rather than from a
+ * rule this file re-implements. A console that decided for itself would
+ * eventually offer a field the host refuses, and the operator would meet the
+ * disagreement as a failed save instead of as a field that will not take an
+ * edit.
+ */
+export function AgentDetailView({
+  client,
+  company,
+  agentId,
+  onBack,
+}: {
+  client: OpenCompanyClient;
+  company: string | null;
+  agentId: string;
+  onBack: () => void;
+}) {
+  const [load, setLoad] = useState<Load>("loading");
+  const [agent, setAgent] = useState<AgentDetailDto | null>(null);
+  const [editing, setEditing] = useState(false);
+  const [draft, setDraft] = useState<AgentDraft>({ name: "", role: "", description: "" });
+  const [saving, setSaving] = useState(false);
+
+  const boot = useCallback(async () => {
+    setLoad("loading");
+    try {
+      const detail = await client.getAgent(agentId, company);
+      setAgent(detail);
+      setDraft(draftFrom(detail));
+      setLoad("ready");
+    } catch (error) {
+      setAgent(null);
+      setLoad(await classifyFailure(error, () => client.listTeam(company), agentId));
+    }
+  }, [client, company, agentId]);
+
+  useEffect(() => {
+    void boot();
+  }, [boot]);
+
+  async function save() {
+    if (!agent) return;
+    const edits = agentEdits(agent, draft);
+    if (!edits) {
+      setEditing(false);
+      return;
+    }
+    setSaving(true);
+    try {
+      const updated = await client.updateAgent(agentId, edits, company);
+      setAgent(updated);
+      setDraft(draftFrom(updated));
+      setEditing(false);
+      toast.success("Agent updated.");
+    } catch (error) {
+      toast.error(
+        error instanceof ApiError && error.status === 409
+          ? error.message
+          : error instanceof Error
+            ? error.message
+            : "Couldn't save this agent.",
+      );
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  return (
+    <div className="flex-1 overflow-y-auto">
+      <div className="mx-auto w-full max-w-3xl space-y-6 px-4 py-6">
+        <Button variant="ghost" size="sm" className="-ml-2" onClick={onBack}>
+          <ArrowLeft className="size-4" /> Back to team
+        </Button>
+
+        {load === "loading" && <Skeleton className="h-64 rounded-xl" />}
+
+        {load === "missing" && (
+          <EmptyState
+            title="This agent is no longer on the roster."
+            body="It may have been removed. Go back to the team to see who is here now."
+          />
+        )}
+
+        {load === "unsupported" && (
+          <EmptyState
+            title="This host can't open an agent yet."
+            body="Opening an agent needs a newer host. The roster still works."
+          />
+        )}
+
+        {load === "error" && (
+          <EmptyState
+            title="Couldn't load this agent."
+            body="The company host didn't answer. Try again in a moment."
+          />
+        )}
+
+        {load === "ready" && agent && (
+          <>
+            <Identity agent={agent} />
+
+            <Section
+              title="Instructions"
+              subtitle="What this agent was defined to do. It frames every turn the agent takes."
+              action={
+                agent.editable.length > 0 &&
+                !editing && (
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    onClick={() => setEditing(true)}
+                    data-testid="agent-edit"
+                  >
+                    <Pencil className="size-4" /> Edit
+                  </Button>
+                )
+              }
+            >
+              {editing ? (
+                <div className="grid gap-4">
+                  <AgentFields
+                    idPrefix="agent-edit"
+                    draft={draft}
+                    onChange={(key: AgentFieldKey, value) =>
+                      setDraft((d) => ({ ...d, [key]: value }))
+                    }
+                    readOnly={(key) => !isEditable(agent, key)}
+                  />
+                  <div className="flex justify-end gap-2">
+                    <Button
+                      variant="ghost"
+                      onClick={() => {
+                        setDraft(draftFrom(agent));
+                        setEditing(false);
+                      }}
+                    >
+                      Cancel
+                    </Button>
+                    <Button
+                      onClick={() => void save()}
+                      disabled={saving || !draftIsValid(agent, draft)}
+                      data-testid="agent-save"
+                    >
+                      Save
+                    </Button>
+                  </div>
+                </div>
+              ) : (
+                <>
+                  <p
+                    className="whitespace-pre-wrap text-sm text-muted-foreground"
+                    data-testid="agent-description"
+                  >
+                    {agent.description?.trim() ||
+                      "No instructions were written for this agent."}
+                  </p>
+                  {agent.editable.length === 0 && (
+                    <p className="text-xs text-muted-foreground" data-testid="agent-readonly-note">
+                      This agent is part of your company blueprint, so its name, role and
+                      instructions are set in company.toml. Its daily budget can still be changed
+                      from the team page.
+                    </p>
+                  )}
+                </>
+              )}
+            </Section>
+
+            <Tools agent={agent} />
+            <Desks agent={agent} />
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+
+/** Name, role, id, and the two facts that classify an agent. */
+function Identity({ agent }: { agent: AgentDetailDto }) {
+  const display = agent.name?.trim() || agent.role;
+  const tone = toneFor(agent.id || display);
+  return (
+    <div className="flex items-start gap-4">
+      <div
+        className={cn(
+          "flex size-14 shrink-0 items-center justify-center rounded-xl text-base font-semibold",
+          TEAM_TONES[tone] ?? "bg-muted text-muted-foreground",
+        )}
+        aria-hidden
+      >
+        {initials(display)}
+      </div>
+      <div className="min-w-0 flex-1 space-y-2">
+        <div>
+          <h2 className="truncate text-2xl font-semibold tracking-tight" data-testid="agent-name">
+            {display}
+          </h2>
+          <p className="truncate text-sm text-muted-foreground" data-testid="agent-role">
+            {agent.role}
+          </p>
+        </div>
+        <div className="flex flex-wrap items-center gap-2">
+          <Badge variant="secondary" className="gap-1" data-testid="agent-tier">
+            <Sparkles className="size-3" /> {tierLabel(agent)}
+          </Badge>
+          <Badge variant="outline" data-testid="agent-source">
+            {agent.source === "manifest" ? "Company blueprint" : "Added here"}
+          </Badge>
+          {agent.inboxEnabled && (
+            <Badge variant="outline" className="gap-1">
+              <Mail className="size-3" /> Inbox
+            </Badge>
+          )}
+          <span className="font-mono text-xs text-muted-foreground" data-testid="agent-id">
+            {agent.id}
+          </span>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+/**
+ * The tool grants, resolved.
+ *
+ * Three facts, because the difference between them is the whole reason this
+ * section exists. What the agent holds. Whether it holds it because it asked or
+ * because it asked for nothing and inherited the company's grant. And what it
+ * asked for and did not get, which is the line an operator checking a tool
+ * change is actually looking for and which no surface showed before.
+ */
+function Tools({ agent }: { agent: AgentDetailDto }) {
+  const summary = summarizeGrants(agent.tools);
+  return (
+    <Section
+      title="Tools"
+      subtitle={
+        summary.standardGrant
+          ? "This agent lists no tools of its own, so it holds everything the company allows."
+          : "What this agent asked for, narrowed by what the company allows."
+      }
+    >
+      {summary.effective.length === 0 ? (
+        <p className="text-sm text-muted-foreground" data-testid="agent-tools-empty">
+          {/* Both ways of holding nothing land here, and they are not the same
+              fact. An agent that asked for nothing under a company that allows
+              nothing has been refused nothing. */}
+          {summary.standardGrant
+            ? "This agent has no tools, because the company allows none."
+            : "This agent has no tools. Nothing it asked for is covered by the company tool list."}
+        </p>
+      ) : (
+        <div className="flex flex-wrap gap-2" data-testid="agent-tools">
+          {summary.effective.map((glob) => (
+            <Badge key={glob} variant="secondary" className="gap-1 font-mono text-xs">
+              <Wrench className="size-3" /> {glob}
+            </Badge>
+          ))}
+        </div>
+      )}
+      {summary.dropped.length > 0 && (
+        <div className="space-y-1" data-testid="agent-tools-dropped">
+          <p className="text-xs text-muted-foreground">
+            Asked for but not granted, because the company tool list does not cover it:
+          </p>
+          <div className="flex flex-wrap gap-2">
+            {summary.dropped.map((glob) => (
+              <Badge key={glob} variant="outline" className="font-mono text-xs line-through">
+                {glob}
+              </Badge>
+            ))}
+          </div>
+        </div>
+      )}
+      <p className="text-xs text-muted-foreground">
+        Company tool list: {agent.tools.companyAllow.join(", ") || "nothing allowed"}
+      </p>
+    </Section>
+  );
+}
+
+/** Desk membership, with the lead named. */
+function Desks({ agent }: { agent: AgentDetailDto }) {
+  return (
+    <Section
+      title="Desks"
+      subtitle="The desks this agent works on. A desk hands its work to its lead first."
+    >
+      {agent.desks.length === 0 ? (
+        <p className="text-sm text-muted-foreground" data-testid="agent-desks-empty">
+          This agent is not on any desk.
+        </p>
+      ) : (
+        <div className="flex flex-wrap gap-2" data-testid="agent-desks">
+          {agent.desks.map((desk) => (
+            <Badge key={desk.id} variant="secondary" className="gap-1">
+              <Users className="size-3" /> {desk.name}
+              {desk.lead && <span className="text-xs opacity-70">(lead)</span>}
+            </Badge>
+          ))}
+        </div>
+      )}
+    </Section>
+  );
+}
+
+function Section({
+  title,
+  subtitle,
+  action,
+  children,
+}: {
+  title: string;
+  subtitle: string;
+  action?: ReactNode;
+  children: ReactNode;
+}) {
+  return (
+    <Card>
+      <CardContent className="space-y-3 py-4">
+        <div className="flex items-start justify-between gap-3">
+          <div className="space-y-1">
+            <h3 className="font-medium">{title}</h3>
+            <p className="text-xs text-muted-foreground">{subtitle}</p>
+          </div>
+          {action}
+        </div>
+        {children}
+      </CardContent>
+    </Card>
+  );
+}
+
+function EmptyState({ title, body }: { title: string; body: string }) {
+  return (
+    <Card>
+      <CardContent className="space-y-1 py-8 text-center">
+        <p className="font-medium">{title}</p>
+        <p className="text-sm text-muted-foreground">{body}</p>
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/frontend/src/views/team/AgentFields.tsx b/frontend/src/views/team/AgentFields.tsx
new file mode 100644
index 00000000..f22ef420
--- /dev/null
+++ b/frontend/src/views/team/AgentFields.tsx
@@ -0,0 +1,72 @@
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Textarea } from "@/components/ui/textarea";
+import { AGENT_FIELDS, type AgentDraft, type AgentFieldKey } from "@/lib/agent";
+
+/**
+ * An agent's authored fields, rendered from one definition (issue #264).
+ *
+ * Used by both "Define an agent" and the detail view's edit form. They collect
+ * the same three things, and rendering them from
+ * [`AGENT_FIELDS`](@/lib/agent) is what keeps the labels, the placeholders and
+ * the order the same in both places rather than the same by coincidence.
+ *
+ * `readOnly` is a predicate rather than a boolean because editability is
+ * per-field and decided by the **host**: the detail response carries an
+ * `editable` list, and a manifest teammate's fields are not in it. A locked
+ * field is still rendered, because "you cannot change this here" is information
+ * an operator needs; hiding it would just recreate the dead end.
+ *
+ * Locked means the native `readOnly`, NOT `disabled`. A disabled input is
+ * removed from the tab order and from the accessibility tree's interactive
+ * surface, so the very values this screen exists to show would be unreachable
+ * by keyboard and awkward to select or copy. `readOnly` refuses the edit and
+ * keeps the value reachable, which is the behaviour a read-only field wants.
+ */
+export function AgentFields({
+  idPrefix,
+  draft,
+  onChange,
+  readOnly,
+}: {
+  /** Namespaces the DOM ids, so two of these can be mounted at once. */
+  idPrefix: string;
+  draft: AgentDraft;
+  onChange: (key: AgentFieldKey, value: string) => void;
+  /** Whether a given field is read-only. Defaults to all-editable. */
+  readOnly?: (key: AgentFieldKey) => boolean;
+}) {
+  return (
+    <>
+      {AGENT_FIELDS.map((field) => {
+        const id = `${idPrefix}-${field.key}`;
+        const locked = readOnly?.(field.key) ?? false;
+        return (
+          <div key={field.key} className="grid gap-2">
+            <Label htmlFor={id}>{field.label}</Label>
+            {field.kind === "prose" ? (
+              <Textarea
+                id={id}
+                rows={4}
+                value={draft[field.key]}
+                readOnly={locked}
+                onChange={(e) => onChange(field.key, e.target.value)}
+                placeholder={field.placeholder}
+                data-testid={`agent-field-${field.key}`}
+              />
+            ) : (
+              <Input
+                id={id}
+                value={draft[field.key]}
+                readOnly={locked}
+                onChange={(e) => onChange(field.key, e.target.value)}
+                placeholder={field.placeholder}
+                data-testid={`agent-field-${field.key}`}
+              />
+            )}
+          </div>
+        );
+      })}
+    </>
+  );
+}
diff --git a/frontend/test/e2e/agent-detail.spec.ts b/frontend/test/e2e/agent-detail.spec.ts
new file mode 100644
index 00000000..95b5734f
--- /dev/null
+++ b/frontend/test/e2e/agent-detail.spec.ts
@@ -0,0 +1,206 @@
+import { expect, test, type Page } from "@playwright/test";
+
+/**
+ * Proof for issue #264: an agent can be opened, read, and edited **from the
+ * Console**, against the live host.
+ *
+ * The issue's complaint is a dead end, so the evidence has to be the walk that
+ * used to end nowhere: start on the Team tab, open a card, and read the things
+ * that had no console surface at all — the instructions the agent was defined
+ * with, its tier, the tools it may actually use, and the desks it sits on. The
+ * tool grants had no *read endpoint* either (`GET …/team` sent `tools: null`
+ * for every member), so this is also the first time that is checkable from
+ * outside the process.
+ *
+ * Runs against the same live host as `wiring.spec.ts` (`companies/e2e_harness`),
+ * whose manifest is what the assertions below are pinned to:
+ *
+ *   * `[tools] allow = ["composio", "mcp:*", "workspace", "workspace.*"]`
+ *   * `ceo` is `tier = "orchestrator"`, asks for `mcp:*`, `composio`,
+ *     `workspace.read`, and sits on no desk
+ *   * `engineer` sits on the Engineering desk
+ *
+ * Default features are enough: the routes this exercises ship in the default
+ * build, so nothing here is behind `capabilities.ts`.
+ *
+ * The spec removes the teammate it creates, so it can run repeatedly against a
+ * host whose data directory persists between runs.
+ */
+
+/** The card for the teammate whose role matches `role`. */
+function card(page: Page, role: string) {
+  return page.getByTestId("team-card").filter({ hasText: role }).first();
+}
+
+/**
+ * A fresh host greets the first visit with a welcome tour rendered over the
+ * console, which swallows clicks on the view beneath it.
+ *
+ * Two halves, and the first is what matters. The tour is suppressed **before
+ * the app boots** by seeding its own localStorage markers through an init
+ * script, so it never renders and there is nothing to wait for. This is the
+ * pattern `board-columns.spec.ts` uses, and it is here for a measured reason:
+ * the earlier version of this helper blocked on `waitFor({ timeout: 15_000 })`
+ * and swallowed the timeout, which costs the FULL fifteen seconds every time
+ * the tour is absent — the common case. This spec navigates three times (the
+ * `beforeEach`, the storage-cleared reload, and the cleanup), so it paid that
+ * toll three times and blew the 60s test budget without a single assertion
+ * failing.
+ *
+ * The click half stays as a belt-and-braces fallback for a host whose marker
+ * key this list does not name, but it polls briefly rather than blocking.
+ */
+async function dismissOnboarding(page: Page) {
+  const skip = page.getByRole("button", { name: "Skip for now" });
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    if (!(await skip.isVisible().catch(() => false))) return;
+    await skip.click({ force: true }).catch(() => {});
+    await page.waitForTimeout(300);
+  }
+  await expect(skip).toHaveCount(0);
+}
+
+async function goToTeam(page: Page) {
+  await page.goto("/#/team");
+  await dismissOnboarding(page);
+  await expect(page.getByTestId("team-card").first()).toBeVisible({ timeout: 30_000 });
+}
+
+test.beforeEach(async ({ page }) => {
+  // Registered before any navigation, so it also re-seeds after the
+  // storage-clearing reload below — which wipes the tour markers along with
+  // everything else and would otherwise bring the tour back mid-test.
+  await page.addInitScript(() => {
+    const seen = JSON.stringify({ skipped: true, seenAt: Date.now() });
+    for (const key of ["oc-tour:single", "oc-tour:e2e-harness-co", "oc-tour:null"]) {
+      window.localStorage.setItem(key, seen);
+    }
+  });
+  await goToTeam(page);
+});
+
+test("a company agent opens from its card and shows what it is", async ({ page }) => {
+  // The walk that used to end nowhere: the card's own name is the way in.
+  await card(page, "Chief Executive").getByTestId("team-card-open").click();
+
+  // A sub-page, not a modal: the agent is addressable, so it survives a
+  // refresh and Back returns to the roster.
+  await expect(page).toHaveURL(/#\/team\/ceo$/);
+
+  await expect(page.getByTestId("agent-name")).toHaveText("Chief Executive");
+  await expect(page.getByTestId("agent-id")).toHaveText("ceo");
+
+  // The tier, resolved by the host rather than read off the manifest string.
+  await expect(page.getByTestId("agent-tier")).toContainText("Orchestrator");
+  await expect(page.getByTestId("agent-source")).toHaveText("Company blueprint");
+
+  // The instructions it was defined with — the "AGENT.md for that agent" the
+  // issue asks for, which the manifest always carried and the console never
+  // showed after creation.
+  await expect(page.getByTestId("agent-description")).toContainText("Sets direction");
+
+  // The effective tool grants. Every one of these is an intersection of the
+  // agent's own `tools` line with the company allow-list, and none of it was
+  // readable anywhere before this issue.
+  const tools = page.getByTestId("agent-tools");
+  await expect(tools).toContainText("workspace.read");
+  await expect(tools).toContainText("composio");
+  await expect(tools).toContainText("mcp:*");
+
+  // This agent sits on no desk, and says so rather than rendering nothing.
+  await expect(page.getByTestId("agent-desks-empty")).toBeVisible();
+
+  // A blueprint teammate is read-only here, and the screen says why instead of
+  // offering an edit that would 409.
+  await expect(page.getByTestId("agent-edit")).toHaveCount(0);
+  await expect(page.getByTestId("agent-readonly-note")).toContainText("company.toml");
+
+  // Back returns to the roster.
+  await page.getByRole("button", { name: "Back to team" }).click();
+  await expect(page.getByTestId("team-card").first()).toBeVisible();
+});
+
+test("desk membership is on the agent, and an agent is reachable by link", async ({ page }) => {
+  // Deep link straight to an agent: the detail view resolves the id against the
+  // host rather than falling back to the roster.
+  await page.goto("/#/team/engineer");
+  await dismissOnboarding(page);
+
+  await expect(page.getByTestId("agent-name")).toHaveText("Engineer", { timeout: 30_000 });
+  await expect(page.getByTestId("agent-tier")).toContainText("Worker");
+  await expect(page.getByTestId("agent-desks")).toContainText("Engineering desk");
+});
+
+test("an agent defined in the console can be read back and edited", async ({ page }) => {
+  const role = "Spec Runner";
+
+  // The `try` opens BEFORE the teammate is created, not after. The POST lands
+  // as soon as the dialog is submitted, so a failure in the assertion that
+  // follows it would otherwise skip the cleanup and leave the teammate on the
+  // host — which breaks the next run of a spec that is meant to be repeatable,
+  // and leaves a second card for `card(page, role)` to match.
+  try {
+    // Define one through the dialog the issue calls create-only.
+    await page.getByRole("button", { name: "Add member" }).first().click();
+    const dialog = page.getByRole("dialog");
+    await dialog.getByTestId("agent-field-name").fill("Detail Spec");
+    await dialog.getByTestId("agent-field-role").fill(role);
+    await dialog.getByTestId("agent-field-description").fill("Original instructions.");
+    await dialog.getByRole("button", { name: "Add member" }).click();
+    await expect(card(page, role)).toBeVisible({ timeout: 30_000 });
+
+    // Open it. This is the half that was impossible: the roster was write-once
+    // per member, so iterating on an agent meant deleting it and starting over.
+    await card(page, role).getByTestId("team-card-open").click();
+    await expect(page.getByTestId("agent-source")).toHaveText("Added here");
+    await expect(page.getByTestId("agent-description")).toContainText("Original instructions.");
+
+    // A console-defined agent holds the company's standard grant, so it reads
+    // back with the whole allow-list rather than an empty tool list.
+    await expect(page.getByTestId("agent-tools")).toContainText("composio");
+
+    // Edit it.
+    await page.getByTestId("agent-edit").click();
+    await page.getByTestId("agent-field-description").fill("Rewritten instructions.");
+    await page.getByTestId("agent-field-role").fill("Spec Runner II");
+    await page.getByTestId("agent-save").click();
+    await expect(page.getByTestId("agent-description")).toContainText("Rewritten instructions.", {
+      timeout: 30_000,
+    });
+
+    // Host-backed, not local state: it survives a storage-cleared reload. This
+    // is the assertion that separates "the console remembers" from "the company
+    // was actually changed".
+    //
+    // `reload`, not `goto(page.url())`. Navigating to the URL the page is
+    // already on is a same-document navigation — the app keeps every piece of
+    // in-memory state, so the two assertions below would pass off the panel's
+    // own state and prove nothing about the host. That is not hypothetical: it
+    // is why this spec went green on the panel while the roster underneath it
+    // was stale.
+    await page.evaluate(() => {
+      localStorage.clear();
+      sessionStorage.clear();
+    });
+    await page.reload();
+    await dismissOnboarding(page);
+    await expect(page.getByTestId("agent-description")).toContainText("Rewritten instructions.", {
+      timeout: 30_000,
+    });
+    await expect(page.getByTestId("agent-role")).toHaveText("Spec Runner II");
+
+    // …and the roster the operator came from agrees, rather than only the panel
+    // they edited in.
+    await page.getByRole("button", { name: "Back to team" }).click();
+    await expect(card(page, "Spec Runner II")).toBeVisible({ timeout: 30_000 });
+  } finally {
+    // Leave the company as we found it, whatever happened above.
+    await goToTeam(page);
+    const leftover = page.getByTestId("team-card").filter({ hasText: "Detail Spec" }).first();
+    if (await leftover.count()) {
+      await leftover.getByLabel("Member actions").click();
+      await page.getByRole("menuitem", { name: "Remove" }).click();
+      await expect(leftover).toHaveCount(0, { timeout: 30_000 });
+    }
+  }
+});
diff --git a/frontend/test/unit/agent-detail.test.ts b/frontend/test/unit/agent-detail.test.ts
new file mode 100644
index 00000000..8d736014
--- /dev/null
+++ b/frontend/test/unit/agent-detail.test.ts
@@ -0,0 +1,157 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  agentEdits,
+  draftFrom,
+  draftIsValid,
+  isEditable,
+  summarizeGrants,
+  tierLabel,
+} from "@/lib/agent";
+import type { AgentDetailDto } from "@/api/types";
+
+/**
+ * The derivations behind the agent detail view (issue #264).
+ *
+ * Each of these is a place where being subtly wrong looks completely normal on
+ * screen: a patch body that erases the instructions it meant to leave alone, a
+ * tool list that reports the opposite of an agent's real grant, a tier that
+ * reads "Worker" for the agent actually running the company. None of them
+ * throws when it is wrong, which is why they are unit-tested rather than left
+ * to the browser suite to notice.
+ */
+
+function agent(over: Partial<AgentDetailDto> = {}): AgentDetailDto {
+  return {
+    id: "jamie",
+    name: "Jamie",
+    role: "Growth",
+    description: "Runs paid acquisition.",
+    source: "overlay",
+    editable: ["name", "role", "description"],
+    isOrchestrator: false,
+    tools: { requested: [], companyAllow: ["workspace.*"], effective: ["workspace.*"] },
+    desks: [],
+    inboxEnabled: false,
+    ...over,
+  };
+}
+
+const manifest = () =>
+  agent({ id: "ceo", name: undefined, role: "Chief Executive", source: "manifest", editable: [] });
+
+describe("what an edit sends", () => {
+  it("sends nothing at all when nothing changed", () => {
+    const detail = agent();
+    expect(agentEdits(detail, draftFrom(detail))).toBeNull();
+  });
+
+  it("sends only the fields that changed", () => {
+    const detail = agent();
+    expect(agentEdits(detail, { ...draftFrom(detail), role: "Head of Growth" })).toEqual({
+      role: "Head of Growth",
+    });
+  });
+
+  it("distinguishes clearing the instructions from leaving them alone", () => {
+    const detail = agent();
+
+    // Emptied on purpose: `null` is the only value the host reads as "clear
+    // it". Sending `undefined` would leave the old text in place and the
+    // operator would watch their deletion come back on the next load.
+    expect(agentEdits(detail, { ...draftFrom(detail), description: "   " })).toEqual({
+      description: null,
+    });
+
+    // Untouched: the key is absent, so the host leaves the instructions be.
+    const untouched = agentEdits(detail, { ...draftFrom(detail), name: "Jamie R" });
+    expect(untouched).toEqual({ name: "Jamie R" });
+    expect(untouched && "description" in untouched).toBe(false);
+  });
+
+  it("trims, so whitespace alone is not a change", () => {
+    const detail = agent();
+    expect(agentEdits(detail, { ...draftFrom(detail), name: "  Jamie  " })).toBeNull();
+  });
+
+  it("never sends a field the host says is read-only", () => {
+    // A manifest teammate's fields are rendered, disabled, so the draft still
+    // holds their values. Echoing one back would earn a 409 for the whole save.
+    const detail = manifest();
+    expect(agentEdits(detail, { name: "Nope", role: "Chief Vibes", description: "New" })).toBeNull();
+    expect(isEditable(detail, "role")).toBe(false);
+  });
+});
+
+describe("whether a draft can be saved", () => {
+  it("requires a name and a role, but not instructions", () => {
+    const detail = agent();
+    expect(draftIsValid(detail, { name: "Jamie", role: "Growth", description: "" })).toBe(true);
+    expect(draftIsValid(detail, { name: "  ", role: "Growth", description: "x" })).toBe(false);
+    expect(draftIsValid(detail, { name: "Jamie", role: "", description: "x" })).toBe(false);
+  });
+
+  it("does not block on a read-only field being blank", () => {
+    // A manifest teammate carries no name of its own, so the disabled name box
+    // is empty. That must not make Save unreachable for a form that has no
+    // editable fields to begin with.
+    expect(draftIsValid(manifest(), { name: "", role: "Chief Executive", description: "" })).toBe(
+      true,
+    );
+  });
+});
+
+describe("what an agent's tools amount to", () => {
+  it("names the standard grant rather than showing an empty request", () => {
+    // The inversion worth guarding: an agent that lists no tools holds
+    // everything the company allows. A surface that rendered `requested` would
+    // tell the operator this agent is powerless.
+    const summary = summarizeGrants({
+      requested: [],
+      companyAllow: ["workspace", "composio"],
+      effective: ["workspace", "composio"],
+    });
+    expect(summary.standardGrant).toBe(true);
+    expect(summary.effective).toEqual(["workspace", "composio"]);
+    expect(summary.dropped).toEqual([]);
+  });
+
+  it("shows what was asked for and not granted", () => {
+    const summary = summarizeGrants({
+      requested: ["workspace.read", "email.send"],
+      companyAllow: ["workspace.*"],
+      effective: ["workspace.read"],
+    });
+    expect(summary.standardGrant).toBe(false);
+    expect(summary.dropped).toEqual(["email.send"]);
+  });
+
+  it("reports an agent that holds nothing", () => {
+    const summary = summarizeGrants({
+      requested: ["email.send"],
+      companyAllow: ["workspace"],
+      effective: [],
+    });
+    expect(summary.effective).toEqual([]);
+    expect(summary.dropped).toEqual(["email.send"]);
+    expect(summary.standardGrant).toBe(false);
+  });
+});
+
+describe("how a tier reads", () => {
+  it("follows the host's resolution rather than the tier string", () => {
+    // A company that tags nobody still has an orchestrator: the first agent
+    // declared. The host resolves it; reading `tier` here would call that
+    // agent a worker.
+    expect(tierLabel(agent({ tier: undefined, isOrchestrator: true }))).toBe("Orchestrator");
+    expect(tierLabel(agent({ tier: "orchestrator", isOrchestrator: true }))).toBe("Orchestrator");
+    expect(tierLabel(agent())).toBe("Worker");
+  });
+});
+
+describe("the draft a detail view starts from", () => {
+  it("shows a manifest teammate by its role, since it carries no name", () => {
+    expect(draftFrom(manifest()).name).toBe("");
+    expect(draftFrom(manifest()).role).toBe("Chief Executive");
+  });
+});
diff --git a/src/company/mod.rs b/src/company/mod.rs
index 45bbde10..c8a36ff4 100644
--- a/src/company/mod.rs
+++ b/src/company/mod.rs
@@ -53,10 +53,10 @@ pub use skill_file::{SkillDoc, load_dir_skills, parse_skill_md, render_skill_md}
 pub use types::{
     Agent, BRAIN_MODES, Brain, Budget, ChannelConfig, Company, CompanyManifest, ComposioTools,
     Connection, DEFAULT_ALWAYS_APPROVE, DEFAULT_SEARCH_DAILY_CALLS, GATEABLE_NAMESPACES,
-    INFERENCE_PROVIDERS, INFERENCE_TIERS, Inference, KNOWN_CHANNELS, McpServer, PLAN_NAMES,
-    PLAN_PERIODS, POLICY_MODES, Place, Plan, Policy, Schedule, Skill, TIERS, TOOL_PROVIDERS, Tools,
-    grants_composio_explicit, grants_media_explicit, grants_search_explicit,
-    grants_workspace_write_explicit,
+    INFERENCE_PROVIDERS, INFERENCE_TIERS, Inference, KNOWN_CHANNELS, McpServer, ORCHESTRATOR_TIER,
+    PLAN_NAMES, PLAN_PERIODS, POLICY_MODES, Place, Plan, Policy, Schedule, Skill, TIERS,
+    TOOL_PROVIDERS, Tools, grants_composio_explicit, grants_media_explicit, grants_search_explicit,
+    grants_workspace_write_explicit, orchestrator_id,
 };
 pub use workflow_file::{
     WORKFLOW_DESTINATION_KINDS, WORKFLOW_NODE_KINDS, WorkflowDestinationDef, WorkflowEdgeDef,
diff --git a/src/company/types.rs b/src/company/types.rs
index 45913fd0..babc9f52 100644
--- a/src/company/types.rs
+++ b/src/company/types.rs
@@ -249,6 +249,32 @@ pub struct Agent {
     pub budget_usd_daily: Option<f64>,
 }
 
+/// The `[[agent]].tier` value that marks a roster's orchestrator.
+pub const ORCHESTRATOR_TIER: &str = "orchestrator";
+
+/// Which teammate acts as the company's orchestrator: the first agent tagged
+/// `tier = "orchestrator"`, else the first agent declared, else `None` for an
+/// empty roster.
+///
+/// Lives here, ungated, because two very different readers need the same
+/// answer. The harness reads it to decide who gets the delegating-orchestrator
+/// persona and tools (`crate::harness::orchestrator::orchestrator_id`, which
+/// delegates here). The console's agent detail route reads it to tell an
+/// operator whether the agent they opened is the orchestrator or a worker
+/// (issue #264) — and that route ships in the default build, where the harness
+/// does not compile at all.
+///
+/// The fallback to the first agent is not a nicety: a company that tags nobody
+/// still has an orchestrator, so a console that reported "worker" for every
+/// teammate on such a roster would be wrong about all of them.
+pub fn orchestrator_id(agents: &[Agent]) -> Option<&str> {
+    agents
+        .iter()
+        .find(|agent| agent.tier.as_deref() == Some(ORCHESTRATOR_TIER))
+        .or_else(|| agents.first())
+        .map(|agent| agent.id.as_str())
+}
+
 /// A `[[group_chat]]` entry — a named conversation with a desk of agents.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct GroupChat {
diff --git a/src/harness/orchestrator.rs b/src/harness/orchestrator.rs
index 19311f24..d75e62fc 100644
--- a/src/harness/orchestrator.rs
+++ b/src/harness/orchestrator.rs
@@ -71,7 +71,11 @@ use crate::ports::types::{CompanyEvent, CompanyId, EventSeq, OverlayAgent};
 use crate::ports::{CompanyStore, WorkflowRun, WorkflowRunner, generate_id};
 
 /// The manifest cognition-tier that marks the orchestrator agent.
-pub const ORCHESTRATOR_TIER: &str = "orchestrator";
+///
+/// Re-exported from [`crate::company`] rather than declared here (issue #264):
+/// the console's agent detail route has to name the same tier in the default
+/// build, where this module does not compile.
+pub use crate::company::ORCHESTRATOR_TIER;
 
 /// Max delegations one orchestrator turn may make (v1 cap) — delegation is
 /// bounded so a runaway turn can't fan out unboundedly.
@@ -111,12 +115,14 @@ pub const REVIEW_TASK_TOOL: &str = "review_task";
 /// `tier = "orchestrator"`, else the first roster agent, else `None` (empty
 /// roster). The fallback is what keeps a company with no tagged orchestrator
 /// answering exactly as it did before this cell.
+///
+/// Delegates to [`crate::company::orchestrator_id`] (issue #264) so the
+/// harness and the console's agent detail route answer "who is the
+/// orchestrator?" from one rule. A second copy of the fallback here would let
+/// the console label a teammate a worker while the harness handed it the
+/// orchestrator's tools.
 pub fn orchestrator_id(agents: &[ManifestAgent]) -> Option<String> {
-    agents
-        .iter()
-        .find(|a| a.tier.as_deref() == Some(ORCHESTRATOR_TIER))
-        .or_else(|| agents.first())
-        .map(|a| a.id.clone())
+    crate::company::orchestrator_id(agents).map(str::to_string)
 }
 
 /// Whether `tool` is one of the orchestrator's in-cycle delegation / roster-write
diff --git a/src/runtime/builder.rs b/src/runtime/builder.rs
index 1d73a361..3d3ce301 100644
--- a/src/runtime/builder.rs
+++ b/src/runtime/builder.rs
@@ -112,9 +112,13 @@ pub fn effective_grants(manifest: &CompanyManifest) -> Vec<String> {
 /// per-agent slice of [`effective_grants`], used by the harness to decide which
 /// tool families an individual agent receives.
 ///
-/// Gated to the `openhuman` feature: its only caller is `build_roster`, which is
-/// itself feature-gated, so the default build would otherwise flag it dead.
-#[cfg(feature = "openhuman")]
+/// Compiled in **every** build since issue #264. It used to be gated to
+/// `openhuman` because `build_roster` was its only caller, but the agent detail
+/// route (`GET {scope}/team/{agent_id}`) now answers the same question for the
+/// console, and that route ships in the default build. Both callers must read
+/// the *same* function or the console would show an operator a tool list the
+/// harness does not actually grant — which is precisely the verification gap
+/// #264 was filed about.
 pub(crate) fn agent_effective_grants(allow: &[String], agent_tools: &[String]) -> Vec<String> {
     let grants: Vec<String> = if agent_tools.is_empty() {
         allow.to_vec()
diff --git a/src/server/ops/language.rs b/src/server/ops/language.rs
index 1362cc6b..107e0457 100644
--- a/src/server/ops/language.rs
+++ b/src/server/ops/language.rs
@@ -21,6 +21,16 @@ pub const BUILTIN_UNINSTALL: &str =
 pub const MANIFEST_TEAMMATE_DELETE: &str =
     "This teammate is part of your company's blueprint and can't be removed here.";
 
+/// Error shown when a write tries to edit a teammate defined in the manifest
+/// (issue #264). Says where the edit belongs, because the answer is not "you
+/// may not" but "not from here" — the blueprint is version-controlled, and the
+/// one thing the console can change on such a teammate is its daily budget,
+/// which is stored as an override rather than as a rewrite.
+pub const MANIFEST_TEAMMATE_EDIT: &str = concat!(
+    "This teammate is part of your company's blueprint. ",
+    "Edit it in company.toml and redeploy; its daily budget can still be changed here.",
+);
+
 /// Error shown when a write tries to remove a desk member defined in the
 /// manifest (only operator-added members can be removed at runtime).
 pub const MANIFEST_DESK_MEMBER_DELETE: &str =
diff --git a/src/server/ops/mod.rs b/src/server/ops/mod.rs
index 42964b7b..b9b52e2a 100644
--- a/src/server/ops/mod.rs
+++ b/src/server/ops/mod.rs
@@ -37,6 +37,11 @@ pub mod smtp;
 pub mod task_export;
 pub mod tasks;
 pub mod team;
+/// Issue #264: one agent, opened — `GET`/`PATCH {scope}/team/{agent_id}`. The
+/// detail read (identity, tier, **resolved** tool grants, desks) and the edit
+/// for the fields the console owns. Attached to [`team`]'s existing
+/// `/team/{agent_id}` route rather than merged as its own. See [`team_agent`].
+mod team_agent;
 pub mod usage;
 pub mod workflows;
 pub mod workspace;
diff --git a/src/server/ops/team.rs b/src/server/ops/team.rs
index c24ae520..6817fd4b 100644
--- a/src/server/ops/team.rs
+++ b/src/server/ops/team.rs
@@ -35,7 +35,7 @@
 use axum::extract::{Path, State};
 use axum::http::{HeaderMap, StatusCode};
 use axum::response::{IntoResponse, Response};
-use axum::routing::{delete, get, put};
+use axum::routing::{get, put};
 use axum::{Json, Router};
 use serde::{Deserialize, Serialize};
 
@@ -54,7 +54,14 @@ use crate::server::users::admin::require_admin;
 /// Builds the team route fragment.
 pub fn router() -> Router<AppState> {
     scoped("/team", get(list_team).post(add_member))
-        .merge(scoped("/team/{agent_id}", delete(remove_member)))
+        // `GET`/`PATCH` come from the sibling `team_agent` module (issue #264)
+        // and are attached to this one entry rather than merged in as a second
+        // router: axum panics when two routers claim the same path, even for
+        // disjoint methods.
+        .merge(scoped(
+            "/team/{agent_id}",
+            super::team_agent::method_router().delete(remove_member),
+        ))
         .merge(scoped("/team/{agent_id}/inbox", put(toggle_inbox)))
         .merge(scoped(
             "/team/{agent_id}/budget",
@@ -142,7 +149,7 @@ struct AddMember {
 /// remove a cap has to say `null` and mean it.
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct SetBudget {
+pub(super) struct SetBudget {
     #[serde(deserialize_with = "double_option")]
     budget_usd_daily: Option<Option<f64>>,
 }
@@ -150,7 +157,7 @@ struct SetBudget {
 /// Deserializes into `Some(inner)` when the field is present (so an explicit
 /// `null` becomes `Some(None)`). Without a companion `#[serde(default)]` an
 /// omitted field stays an error — which is what [`SetBudget`] wants.
-fn double_option<'de, D, T>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
+pub(super) fn double_option<'de, D, T>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
 where
     D: serde::Deserializer<'de>,
     T: Deserialize<'de>,
@@ -171,10 +178,11 @@ struct InboxAck {
     address: String,
 }
 
-/// The sub-resource path (`agent_id`).
+/// The sub-resource path (`agent_id`). Shared with the sibling `team_agent`
+/// module, which serves `GET`/`PATCH` on the same path (issue #264).
 #[derive(Debug, Deserialize)]
-struct AgentPath {
-    agent_id: String,
+pub(super) struct AgentPath {
+    pub(super) agent_id: String,
 }
 
 /// `GET {scope}/team` — the merged roster: manifest teammates (versioned in
@@ -287,7 +295,7 @@ fn member_row(
 /// spend beside it; and overlay teammates are now cappable, so restricting the
 /// scan to manifest agents would miss the only capped teammate on a company
 /// whose roster was built entirely from the console.
-async fn daily_spend_samples(
+pub(super) async fn daily_spend_samples(
     company: &ScopedCompany,
     record: Option<&CompanyRecord>,
 ) -> Result<Option<Vec<crate::ports::usage::UsageSample>>, ApiError> {
diff --git a/src/server/ops/team_agent.rs b/src/server/ops/team_agent.rs
new file mode 100644
index 00000000..cc8e4556
--- /dev/null
+++ b/src/server/ops/team_agent.rs
@@ -0,0 +1,870 @@
+//! One agent, opened: the detail read and the edit behind `GET`/`PATCH
+//! {scope}/team/{agent_id}` (issue #264).
+//!
+//! Before this, an agent was a dead end. `GET …/team` returned a name, a role
+//! and a description; nothing carried the agent's tier, its tool grants or its
+//! desks, and there was no per-agent route at all. So the console could show a
+//! card and offer to delete it, and that was the whole of what an operator
+//! could learn or do. Worse than the missing screen: **checking what tools a
+//! company actually grants an agent had no read surface anywhere**, which is
+//! why a tool-grant change could not be verified from outside the process.
+//!
+//! ## Effective, not declared
+//!
+//! [`AgentToolsDto`] carries three lists rather than one, because the
+//! interesting number is the one nobody could see. `requested` is what the
+//! `[[agent]].tools` line asks for, `companyAllow` is the `[tools].allow`
+//! ceiling it is intersected with, and `effective` is what the agent actually
+//! ends up holding. An agent that requests `workspace.read` under a company
+//! that allows only `composio` requests one tool and holds none, and a surface
+//! that printed the request alone would report the opposite of the truth.
+//!
+//! `effective` is computed by
+//! [`agent_effective_grants`](crate::runtime::builder::agent_effective_grants)
+//! — the *same* function the harness calls when it builds the agent, not a
+//! re-implementation of the rule. A second copy would eventually disagree, and
+//! a tool-grant readout that disagrees with the harness is worse than none.
+//!
+//! ## What may be edited, and why that is the line
+//!
+//! The console edits what the console owns.
+//!
+//! An **overlay** teammate — one an operator defined through "Define an agent",
+//! or the orchestrator created with `add_agent` — lives on the
+//! [`CompanyRecord`], which this process writes. Its name, role and description
+//! are editable here, and that is the whole of #264's "the roster is write-once
+//! per member" complaint: before this, iterating on an agent's instructions
+//! meant deleting it and starting over.
+//!
+//! A **manifest** teammate is declared in the version-controlled `company.toml`
+//! and is not editable from a browser. This is the same line
+//! [`MANIFEST_TEAMMATE_DELETE`](super::language::MANIFEST_TEAMMATE_DELETE)
+//! already draws for removal, and it is drawn in the same place for the same
+//! reason: the manifest is the company's blueprint, the overlay model exists so
+//! the runtime never rewrites it, and a console PATCH that edited it would make
+//! the deployed company silently diverge from the file in git.
+//!
+//! The one field that *is* editable on a manifest teammate — its daily budget —
+//! is editable precisely because #343 modelled it as a
+//! [`BudgetOverride`](crate::ports::types::BudgetOverride) layered on top rather
+//! than as a rewrite. It keeps its own route and is untouched here.
+//!
+//! `tier` and `tools` are read-only for **both** kinds. There is no override
+//! layer for either, and inventing one is a policy decision (an operator
+//! raising an agent's own tool grants from a browser is a privilege question,
+//! not a form field), not something to smuggle into a detail view.
+//!
+//! The server states the rule rather than leaving the console to re-derive it:
+//! every detail response carries an [`editable`](AgentDetailDto::editable) list,
+//! and the console renders a field read-only exactly when the host says it is.
+//! A console that decided this for itself would drift from what the host
+//! actually accepts, and the operator would meet the disagreement as a failed
+//! save.
+
+use axum::Json;
+use axum::extract::Path;
+use axum::response::{IntoResponse, Response};
+use axum::routing::{self, MethodRouter};
+use serde::{Deserialize, Serialize};
+
+use crate::AppState;
+use crate::error::OpenCompanyError;
+use crate::ports::store::company_write_lock;
+use crate::ports::types::CompanyRecord;
+use crate::runtime::builder::agent_effective_grants;
+use crate::server::error::ApiError;
+use crate::server::ops::ScopedCompany;
+use crate::server::ops::language;
+use crate::server::ops::team::{AgentPath, daily_spend_samples, double_option};
+
+/// The `{scope}/team/{agent_id}` fragment: read one agent, edit one agent.
+///
+/// Merged into [`super::team::router`]'s existing `/team/{agent_id}` entry
+/// rather than declared as its own route — axum panics on two routers claiming
+/// one path, even for disjoint methods.
+pub(super) fn method_router() -> MethodRouter<AppState> {
+    routing::get(agent_detail).patch(edit_agent)
+}
+
+/// Which half of the roster a teammate comes from, and therefore what may be
+/// done to it.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub(super) enum AgentSource {
+    /// Declared in the version-controlled `company.toml`.
+    Manifest,
+    /// Added at runtime by an operator or the orchestrator, stored on the
+    /// company record.
+    Overlay,
+}
+
+/// The fields a `PATCH` accepts for an overlay teammate. Sent to the console so
+/// it renders the same rule the host enforces.
+const OVERLAY_EDITABLE: [&str; 3] = ["name", "role", "description"];
+
+/// One agent, in full — everything #264 lists as unreachable.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct AgentDetailDto {
+    id: String,
+    /// Absent for a manifest teammate, which is named by its role. Same rule as
+    /// `GET …/team`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    name: Option<String>,
+    role: String,
+    /// What the agent was defined with. This is the text that frames the
+    /// agent's persona for every turn it takes, which is what the issue means
+    /// by "the `AGENT.md` or similar file for that agent" — the manifest
+    /// already carries it, the console just never showed it after creation.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    description: Option<String>,
+    source: AgentSource,
+    /// The field names a `PATCH` will accept for this teammate. Empty for a
+    /// manifest teammate.
+    editable: Vec<&'static str>,
+    /// The declared cognition-tier hint, when the manifest sets one. An overlay
+    /// teammate has none by construction.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    tier: Option<String>,
+    /// Whether this teammate is the company's orchestrator — resolved by the
+    /// roster rule (tagged tier first, else the first declared agent), not read
+    /// off `tier` alone, so an untagged roster's real orchestrator is named.
+    is_orchestrator: bool,
+    tools: AgentToolsDto,
+    desks: Vec<AgentDeskDto>,
+    inbox_enabled: bool,
+    /// The cap in force, its spend, and its attribution — the same fields and
+    /// the same absent-means-uncapped contract as `GET …/team`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    budget_usd_daily: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    spent_today_usd: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    budget_set_by: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    budget_set_at_millis: Option<u64>,
+}
+
+/// An agent's tool grants at all three levels, so the resolution is legible
+/// rather than asserted.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct AgentToolsDto {
+    /// The globs the agent asks for. **Empty means "the company's standard
+    /// grant"**, not "no tools" — an agent that lists nothing inherits the whole
+    /// allow-list. The console has to say which of the two it is looking at.
+    requested: Vec<String>,
+    /// The company-wide `[tools].allow` ceiling.
+    company_allow: Vec<String>,
+    /// What the agent actually holds, after the intersection.
+    effective: Vec<String>,
+}
+
+/// A desk this agent sits on.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct AgentDeskDto {
+    id: String,
+    name: String,
+    /// Whether this agent is the desk's lead — the first effective member, who
+    /// receives a `delegate_to_desk` hand-off.
+    lead: bool,
+}
+
+/// The `PATCH` body. Every field is optional, and an absent field is left
+/// alone: this is a patch, not a replacement, so a console that renders only
+/// some of an agent's fields cannot blank the rest by omission.
+///
+/// `description` is a **double option** so "leave it" and "clear it" stay
+/// apart on the wire, the same shape and for the same reason as
+/// [`SetBudget`](super::team::SetBudget)'s cap:
+///
+/// | body | parses as | means |
+/// |---|---|---|
+/// | `{}` | `None` | leave the description alone |
+/// | `{"description": null}` | `Some(None)` | clear it |
+/// | `{"description": "…"}` | `Some(Some(…))` | set it |
+///
+/// Collapsing the first two would make every partial save silently erase an
+/// agent's instructions, which is the single worst thing this route could do.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct EditAgent {
+    #[serde(default)]
+    name: Option<String>,
+    #[serde(default)]
+    role: Option<String>,
+    #[serde(default, deserialize_with = "double_option")]
+    description: Option<Option<String>>,
+}
+
+/// `GET {scope}/team/{agent_id}` — one agent, read.
+async fn agent_detail(
+    company: ScopedCompany,
+    Path(AgentPath { agent_id }): Path<AgentPath>,
+) -> Result<Json<AgentDetailDto>, ApiError> {
+    let record = company
+        .runtime
+        .store()
+        .load(company.id())
+        .await?
+        .ok_or_else(|| OpenCompanyError::CompanyNotFound(company.id().to_string()))?;
+    detail(&company, &record, &agent_id).await
+}
+
+/// `PATCH {scope}/team/{agent_id}` — edit an overlay teammate.
+///
+/// Refuses a manifest teammate with a `409` naming where the edit belongs, and
+/// an unknown id with a `404`. Open to any signed-in member, matching `POST
+/// …/team`: defining a teammate was never admin-only, so correcting one it
+/// defined is not either. Setting a *budget* still is, on its own route.
+async fn edit_agent(
+    company: ScopedCompany,
+    Path(AgentPath { agent_id }): Path<AgentPath>,
+    Json(body): Json<EditAgent>,
+) -> Result<Json<AgentDetailDto>, Response> {
+    // Serialize with every other write to `overlay_agents`, so a console edit
+    // and a concurrent `add_agent` cannot clobber one another's roster.
+    let write_lock = company_write_lock(company.id());
+    let _lock = write_lock.lock().await;
+
+    let mut record = company
+        .runtime
+        .store()
+        .load(company.id())
+        .await
+        .map_err(|e| ApiError(e).into_response())?
+        .ok_or_else(|| {
+            ApiError(OpenCompanyError::CompanyNotFound(company.id().to_string())).into_response()
+        })?;
+
+    // Identity before validation, so an unknown id is a 404 rather than a
+    // complaint about the shape of a body nobody could have applied anyway.
+    if record.manifest.agents.iter().any(|a| a.id == agent_id) {
+        return Err(ApiError(OpenCompanyError::Conflict(
+            language::MANIFEST_TEAMMATE_EDIT.to_string(),
+        ))
+        .into_response());
+    }
+    if !record.overlay_agents.iter().any(|a| a.id == agent_id) {
+        return Err(ApiError(OpenCompanyError::CompanyNotFound(format!(
+            "teammate {agent_id}"
+        )))
+        .into_response());
+    }
+
+    let name = trimmed_field(body.name.as_deref(), "name").map_err(|e| e.into_response())?;
+    let role = trimmed_field(body.role.as_deref(), "role").map_err(|e| e.into_response())?;
+
+    {
+        let agent = record
+            .overlay_agents
+            .iter_mut()
+            .find(|a| a.id == agent_id)
+            .expect("overlay membership was checked above");
+        if let Some(name) = name {
+            agent.name = name;
+        }
+        if let Some(role) = role {
+            agent.role = role;
+        }
+        // Present-and-null clears; a blank string clears too, since an empty
+        // description and no description frame the persona identically and
+        // storing `Some("")` would only make the two look different on the wire.
+        if let Some(description) = body.description {
+            agent.description = description
+                .map(|text| text.trim().to_string())
+                .filter(|text| !text.is_empty());
+        }
+    }
+
+    company
+        .runtime
+        .store()
+        .save(&record)
+        .await
+        .map_err(|e| ApiError(e).into_response())?;
+
+    detail(&company, &record, &agent_id)
+        .await
+        .map_err(|e| e.into_response())
+}
+
+/// Rejects a field that was sent but is blank, and trims one that was sent.
+///
+/// A teammate whose name is whitespace renders as an empty card with no way
+/// back to it, so the refusal is a `400` rather than a stored blank.
+///
+/// The error is an [`ApiError`], **not** the `Response` its caller returns.
+/// `clippy::result_large_err` fires on the second shape here and is right to:
+/// an `axum` `Response` is 128+ bytes, so a `Result<Option<String>, Response>`
+/// makes every successful call carry the footprint of the refusal it did not
+/// make. The handler is exempt only because its own `Ok` variant is larger
+/// still. The caller converts at the boundary, which is also what the sibling
+/// refusal helpers in `team.rs` do by returning `Option<Response>`.
+fn trimmed_field(value: Option<&str>, field: &str) -> Result<Option<String>, ApiError> {
+    let Some(value) = value else {
+        return Ok(None);
+    };
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        return Err(ApiError(OpenCompanyError::InvalidRequest(format!(
+            "a teammate's {field} can't be empty."
+        ))));
+    }
+    Ok(Some(trimmed.to_string()))
+}
+
+/// Builds one agent's detail from the loaded record, or 404s when the id names
+/// nobody on the roster.
+async fn detail(
+    company: &ScopedCompany,
+    record: &CompanyRecord,
+    agent_id: &str,
+) -> Result<Json<AgentDetailDto>, ApiError> {
+    let manifest_agent = record.manifest.agents.iter().find(|a| a.id == agent_id);
+    let overlay_agent = record.overlay_agents.iter().find(|a| a.id == agent_id);
+
+    let (source, name, role, description, tier, requested) = match (manifest_agent, overlay_agent) {
+        // A manifest agent wins an id collision, exactly as `build_roster`
+        // resolves one: the version-controlled roster is authoritative.
+        (Some(agent), _) => (
+            AgentSource::Manifest,
+            None,
+            agent.role.clone(),
+            agent.description.clone(),
+            agent.tier.clone(),
+            agent.tools.clone(),
+        ),
+        (None, Some(agent)) => (
+            AgentSource::Overlay,
+            Some(agent.name.clone()),
+            agent.role.clone(),
+            agent.description.clone(),
+            // An overlay teammate has no manifest row, so no tier and no
+            // per-agent tool line: it holds the company's standard grant. This
+            // mirrors `harness::overlay_agent_to_manifest` exactly.
+            None,
+            Vec::new(),
+        ),
+        (None, None) => {
+            return Err(ApiError(OpenCompanyError::CompanyNotFound(format!(
+                "teammate {agent_id}"
+            ))));
+        }
+    };
+
+    let company_allow = record.manifest.tools.allow.clone();
+    let effective = agent_effective_grants(&company_allow, &requested);
+
+    let cap = record.effective_budget(agent_id);
+    let attribution = record.budget_override(agent_id);
+    let spend_today = daily_spend_samples(company, Some(record)).await?;
+    let spent = cap.and(
+        spend_today
+            .as_ref()
+            .map(|samples| crate::metering::usd_spent_by_agent(samples, agent_id)),
+    );
+
+    let inbox_enabled = company
+        .runtime
+        .inbox()
+        .inboxes(company.id())
+        .await?
+        .into_iter()
+        .any(|meta| meta.key == agent_id && meta.enabled);
+
+    Ok(Json(AgentDetailDto {
+        id: agent_id.to_string(),
+        name,
+        role,
+        description,
+        source,
+        editable: match source {
+            AgentSource::Overlay => OVERLAY_EDITABLE.to_vec(),
+            AgentSource::Manifest => Vec::new(),
+        },
+        tier,
+        is_orchestrator: crate::company::orchestrator_id(&record.manifest.agents) == Some(agent_id),
+        tools: AgentToolsDto {
+            requested,
+            company_allow,
+            effective,
+        },
+        desks: desks_for(record, agent_id),
+        inbox_enabled,
+        budget_usd_daily: cap,
+        spent_today_usd: spent,
+        budget_set_by: attribution.map(|entry| entry.set_by.id.clone()),
+        budget_set_at_millis: attribution.map(|entry| entry.at_millis),
+    }))
+}
+
+/// Every desk this agent is an effective member of, manifest desks first.
+///
+/// Resolved through
+/// [`CompanyRecord::effective_desk_members`](crate::ports::types::CompanyRecord::effective_desk_members)
+/// rather than by reading the declared member lists, so an operator-added
+/// membership and an operator-set lead order are both reflected — the same
+/// answer the Desks page and the harness `desk_lead` resolver give.
+fn desks_for(record: &CompanyRecord, agent_id: &str) -> Vec<AgentDeskDto> {
+    let declared = record
+        .manifest
+        .group_chats
+        .iter()
+        .map(|chat| (chat.id.as_str(), chat.name.as_str()))
+        .chain(
+            record
+                .overlay_desks
+                .iter()
+                .map(|desk| (desk.id.as_str(), desk.name.as_str())),
+        );
+    declared
+        .filter_map(|(id, name)| {
+            let members = record.effective_desk_members(id);
+            members.iter().any(|m| m == agent_id).then(|| AgentDeskDto {
+                id: id.to_string(),
+                name: name.to_string(),
+                lead: members.first().map(String::as_str) == Some(agent_id),
+            })
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use axum::body::{Body, to_bytes};
+    use axum::http::{Request, StatusCode};
+    use serde_json::{Value, json};
+    use tower::ServiceExt;
+
+    use crate::company::CompanyManifest;
+    use crate::ports::CompanyStore;
+    use crate::ports::types::{CompanyId, CompanyRecord};
+    use crate::runtime::RuntimeBuilder;
+    use crate::server::router;
+    use crate::store::FsCompanyStore;
+    use crate::{AppConfig, AppState};
+
+    /// A company whose grants actually bite: `ceo` asks for one tool the company
+    /// does not allow, `writer` asks for nothing at all, and `hermit` sits on no
+    /// desk. Each of those is a different arm of the resolution under test.
+    const ROSTER: &str = r#"
+[company]
+name = "Acme"
+[policy]
+mode = "full"
+[tools]
+allow = ["workspace", "workspace.*", "composio"]
+
+[[agent]]
+id = "ceo"
+role = "Chief Executive"
+description = "Sets direction and delegates."
+tier = "orchestrator"
+tools = ["workspace.read", "email.send"]
+
+[[agent]]
+id = "writer"
+role = "Writer"
+
+[[agent]]
+id = "hermit"
+role = "Hermit"
+
+[[group_chat]]
+id = "content"
+name = "Content desk"
+members = ["writer", "ceo"]
+"#;
+
+    fn home() -> tempfile::TempDir {
+        tempfile::Builder::new()
+            .prefix("oc-agent-detail-")
+            .tempdir()
+            .expect("tempdir")
+    }
+
+    async fn state_with_manifest(home: &std::path::Path, manifest_toml: &str) -> AppState {
+        let manifest: CompanyManifest = toml::from_str(manifest_toml).unwrap();
+        let store = FsCompanyStore::new(home.to_path_buf());
+        let id = CompanyId::new("acme");
+        store
+            .save(&CompanyRecord {
+                id: id.clone(),
+                manifest: manifest.clone(),
+                ledger: Vec::new(),
+                lifecycle: "running".to_string(),
+                overlay_agents: Vec::new(),
+                overlay_desk_members: Vec::new(),
+                overlay_desk_order: Vec::new(),
+                overlay_desks: Vec::new(),
+                overlay_workflows: Vec::new(),
+                overlay_budgets: Vec::new(),
+                template_provenance: None,
+            })
+            .await
+            .unwrap();
+        let runtime = RuntimeBuilder::new(home.to_path_buf(), manifest)
+            .with_id(id.clone())
+            .build()
+            .await
+            .unwrap();
+        let state = AppState::new(AppConfig::default());
+        state.registry().insert(id, std::sync::Arc::new(runtime));
+        crate::server::test_support::seed_fixed_admin(&state, "acme").await;
+        state
+    }
+
+    async fn send(
+        state: &AppState,
+        method: &str,
+        uri: &str,
+        body: Option<Value>,
+    ) -> (StatusCode, Value) {
+        let builder = Request::builder()
+            .method(method)
+            .uri(uri)
+            .header("cookie", crate::server::test_support::fixed_cookie("acme"));
+        let request = match &body {
+            Some(value) => builder
+                .header("content-type", "application/json")
+                .body(Body::from(serde_json::to_vec(value).unwrap()))
+                .unwrap(),
+            None => builder.body(Body::empty()).unwrap(),
+        };
+        let response = router(state.clone()).oneshot(request).await.unwrap();
+        let status = response.status();
+        let bytes = to_bytes(response.into_body(), usize::MAX).await.unwrap();
+        let value = if bytes.is_empty() {
+            Value::Null
+        } else {
+            serde_json::from_slice(&bytes).unwrap_or(Value::Null)
+        };
+        (status, value)
+    }
+
+    async fn get_agent(state: &AppState, agent: &str) -> (StatusCode, Value) {
+        send(state, "GET", &format!("/api/v1/company/team/{agent}"), None).await
+    }
+
+    async fn patch_agent(state: &AppState, agent: &str, body: Value) -> (StatusCode, Value) {
+        send(
+            state,
+            "PATCH",
+            &format!("/api/v1/company/team/{agent}"),
+            Some(body),
+        )
+        .await
+    }
+
+    /// Adds a teammate through the console's own route and returns its id.
+    async fn add_overlay(state: &AppState, name: &str, role: &str) -> String {
+        let (status, created) = send(
+            state,
+            "POST",
+            "/api/v1/company/team",
+            Some(json!({"name": name, "role": role, "description": "Original."})),
+        )
+        .await;
+        assert_eq!(status, StatusCode::OK, "{created}");
+        created["id"].as_str().unwrap().to_string()
+    }
+
+    fn strings(value: &Value) -> Vec<String> {
+        value
+            .as_array()
+            .unwrap_or_else(|| panic!("expected an array, got {value}"))
+            .iter()
+            .map(|v| v.as_str().unwrap().to_string())
+            .collect()
+    }
+
+    // --- The read half (issue #264) -----------------------------------------
+
+    /// The whole of what the issue calls unreachable, on the wire: tier,
+    /// description, resolved tools and desk membership for a manifest teammate.
+    #[tokio::test]
+    async fn a_manifest_agent_opens_with_its_tier_tools_and_desks() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+
+        let (status, ceo) = get_agent(&state, "ceo").await;
+        assert_eq!(status, StatusCode::OK, "{ceo}");
+
+        assert_eq!(ceo["id"], "ceo");
+        assert_eq!(ceo["role"], "Chief Executive");
+        assert_eq!(ceo["description"], "Sets direction and delegates.");
+        assert_eq!(ceo["source"], "manifest");
+        assert_eq!(ceo["tier"], "orchestrator");
+        assert_eq!(ceo["isOrchestrator"], true, "{ceo}");
+        assert!(
+            ceo["name"].is_null(),
+            "a manifest teammate is named by its role: {ceo}"
+        );
+
+        // Desk membership, with the lead flag resolved from the effective order
+        // rather than from the declared list — `writer` is declared first.
+        let desks = ceo["desks"].as_array().unwrap();
+        assert_eq!(desks.len(), 1, "{ceo}");
+        assert_eq!(desks[0]["id"], "content");
+        assert_eq!(desks[0]["name"], "Content desk");
+        assert_eq!(desks[0]["lead"], false, "the writer leads this desk: {ceo}");
+
+        // A teammate on no desk says so with an empty list rather than by
+        // omitting the key, so the console can render "no desks" for sure.
+        let (_, hermit) = get_agent(&state, "hermit").await;
+        assert_eq!(hermit["desks"].as_array().unwrap().len(), 0, "{hermit}");
+        assert_eq!(hermit["isOrchestrator"], false, "{hermit}");
+    }
+
+    /// The verification gap the issue names: what an agent *asks* for and what
+    /// it *holds* are different lists, and only the second one matters.
+    ///
+    /// `ceo` requests `email.send`, which `[tools].allow` does not cover, so it
+    /// is dropped. `writer` requests nothing, which means the company's standard
+    /// grant rather than no tools at all — the opposite reading, and the one a
+    /// naive surface would get wrong.
+    #[tokio::test]
+    async fn effective_tools_are_the_intersection_not_the_request() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+
+        let (_, ceo) = get_agent(&state, "ceo").await;
+        assert_eq!(
+            strings(&ceo["tools"]["requested"]),
+            vec!["workspace.read", "email.send"],
+            "{ceo}"
+        );
+        assert_eq!(
+            strings(&ceo["tools"]["companyAllow"]),
+            vec!["workspace", "workspace.*", "composio"],
+            "{ceo}"
+        );
+        assert_eq!(
+            strings(&ceo["tools"]["effective"]),
+            vec!["workspace.read"],
+            "a request the company never allowed is not a grant: {ceo}"
+        );
+
+        let (_, writer) = get_agent(&state, "writer").await;
+        assert!(
+            strings(&writer["tools"]["requested"]).is_empty(),
+            "{writer}"
+        );
+        assert_eq!(
+            strings(&writer["tools"]["effective"]),
+            vec!["workspace", "workspace.*", "composio"],
+            "an agent that lists no tools holds the company's whole allow-list, \
+             which is the reading a surface must not invert: {writer}"
+        );
+    }
+
+    /// A roster that tags nobody still has an orchestrator: the first declared
+    /// agent. A console that read `tier` alone would call every teammate on such
+    /// a company a worker, and be wrong about all of them.
+    #[tokio::test]
+    async fn an_untagged_roster_still_names_an_orchestrator() {
+        let home_dir = home();
+        let state = state_with_manifest(
+            home_dir.path(),
+            "[company]\nname = \"Acme\"\n[policy]\nmode = \"full\"\n\
+             [[agent]]\nid = \"writer\"\nrole = \"Writer\"\n\
+             [[agent]]\nid = \"editor\"\nrole = \"Editor\"\n",
+        )
+        .await;
+
+        let (_, writer) = get_agent(&state, "writer").await;
+        assert!(writer["tier"].is_null(), "{writer}");
+        assert_eq!(writer["isOrchestrator"], true, "{writer}");
+
+        let (_, editor) = get_agent(&state, "editor").await;
+        assert_eq!(editor["isOrchestrator"], false, "{editor}");
+    }
+
+    /// An operator-added membership counts: the detail view resolves desks
+    /// through `effective_desk_members`, not through the manifest's list.
+    #[tokio::test]
+    async fn an_operator_added_desk_membership_shows_on_the_agent() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+
+        assert_eq!(
+            get_agent(&state, "hermit").await.1["desks"]
+                .as_array()
+                .unwrap()
+                .len(),
+            0
+        );
+
+        let (status, _) = send(
+            &state,
+            "POST",
+            "/api/v1/company/desks/content/members",
+            Some(json!({"agent_id": "hermit"})),
+        )
+        .await;
+        assert_eq!(status, StatusCode::NO_CONTENT);
+
+        let (_, hermit) = get_agent(&state, "hermit").await;
+        let desks = hermit["desks"].as_array().unwrap();
+        assert_eq!(desks.len(), 1, "{hermit}");
+        assert_eq!(desks[0]["id"], "content", "{hermit}");
+    }
+
+    /// An overlay teammate reads back with the company's standard grant and no
+    /// tier, which is exactly what the harness builds it with.
+    #[tokio::test]
+    async fn an_overlay_teammate_reports_the_standard_grant() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+        let jamie = add_overlay(&state, "Jamie", "Growth").await;
+
+        let (status, agent) = get_agent(&state, &jamie).await;
+        assert_eq!(status, StatusCode::OK, "{agent}");
+        assert_eq!(agent["source"], "overlay");
+        assert_eq!(agent["name"], "Jamie");
+        assert!(agent["tier"].is_null(), "{agent}");
+        assert_eq!(agent["isOrchestrator"], false, "{agent}");
+        assert!(strings(&agent["tools"]["requested"]).is_empty(), "{agent}");
+        assert_eq!(
+            strings(&agent["tools"]["effective"]),
+            vec!["workspace", "workspace.*", "composio"],
+            "{agent}"
+        );
+    }
+
+    // --- The edit half ------------------------------------------------------
+
+    /// The issue's "write-once per member", gone: a console-defined teammate can
+    /// be corrected, and the correction is on the host rather than in a tab.
+    #[tokio::test]
+    async fn an_overlay_teammate_can_be_edited_and_the_edit_persists() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+        let jamie = add_overlay(&state, "Jamie", "Growth").await;
+
+        let (status, edited) = patch_agent(
+            &state,
+            &jamie,
+            json!({"name": "Jamie R", "role": "Head of Growth", "description": "Runs paid."}),
+        )
+        .await;
+        assert_eq!(status, StatusCode::OK, "{edited}");
+        assert_eq!(edited["name"], "Jamie R", "{edited}");
+        assert_eq!(edited["role"], "Head of Growth", "{edited}");
+        assert_eq!(edited["description"], "Runs paid.", "{edited}");
+
+        // Read back through a fresh request, so this is the stored record and
+        // not the handler's own answer.
+        let (_, reread) = get_agent(&state, &jamie).await;
+        assert_eq!(reread["name"], "Jamie R", "{reread}");
+        assert_eq!(reread["role"], "Head of Growth", "{reread}");
+
+        // …and the roster list agrees, so the card the operator came from is
+        // updated too rather than only the panel they edited in.
+        let (_, roster) = send(&state, "GET", "/api/v1/company/team", None).await;
+        let row = roster
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|m| m["id"] == jamie.as_str())
+            .unwrap()
+            .clone();
+        assert_eq!(row["name"], "Jamie R", "{row}");
+        assert_eq!(row["role"], "Head of Growth", "{row}");
+    }
+
+    /// A patch leaves what it does not mention alone, and an explicit `null`
+    /// clears the description. Collapsing those two would make every partial
+    /// save erase an agent's instructions.
+    #[tokio::test]
+    async fn an_absent_field_is_left_alone_and_null_clears_the_description() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+        let jamie = add_overlay(&state, "Jamie", "Growth").await;
+
+        let (status, only_role) = patch_agent(&state, &jamie, json!({"role": "Growth Lead"})).await;
+        assert_eq!(status, StatusCode::OK, "{only_role}");
+        assert_eq!(only_role["name"], "Jamie", "{only_role}");
+        assert_eq!(
+            only_role["description"], "Original.",
+            "an unmentioned field survives the patch: {only_role}"
+        );
+
+        let (status, cleared) = patch_agent(&state, &jamie, json!({"description": null})).await;
+        assert_eq!(status, StatusCode::OK, "{cleared}");
+        assert!(
+            cleared["description"].is_null(),
+            "an explicit null clears it: {cleared}"
+        );
+        assert_eq!(cleared["role"], "Growth Lead", "{cleared}");
+    }
+
+    /// The blueprint is not editable from a browser: a manifest teammate is a
+    /// `409` naming where the edit belongs, and nothing is written.
+    #[tokio::test]
+    async fn a_manifest_teammate_cannot_be_edited_here() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+
+        let (status, refusal) = patch_agent(&state, "ceo", json!({"role": "Chief Vibes"})).await;
+        assert_eq!(status, StatusCode::CONFLICT, "{refusal}");
+
+        let (_, ceo) = get_agent(&state, "ceo").await;
+        assert_eq!(ceo["role"], "Chief Executive", "{ceo}");
+        assert!(
+            ceo["editable"].as_array().unwrap().is_empty(),
+            "and the host says so up front, so the console never offers the \
+             field: {ceo}"
+        );
+    }
+
+    /// The console renders read-only from the host's answer, not from a rule of
+    /// its own — so this list is part of the contract.
+    #[tokio::test]
+    async fn the_host_states_which_fields_are_editable() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+        let jamie = add_overlay(&state, "Jamie", "Growth").await;
+
+        let (_, agent) = get_agent(&state, &jamie).await;
+        assert_eq!(
+            strings(&agent["editable"]),
+            vec!["name", "role", "description"],
+            "{agent}"
+        );
+    }
+
+    /// A blank name would render a card with no way back to it, so it is a
+    /// refusal rather than a stored blank. Whitespace is trimmed, not accepted.
+    #[tokio::test]
+    async fn a_blank_name_or_role_is_refused() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+        let jamie = add_overlay(&state, "Jamie", "Growth").await;
+
+        for body in [json!({"name": "   "}), json!({"role": ""})] {
+            let (status, refusal) = patch_agent(&state, &jamie, body.clone()).await;
+            assert_eq!(status, StatusCode::BAD_REQUEST, "{body} → {refusal}");
+        }
+
+        let (status, trimmed) = patch_agent(&state, &jamie, json!({"name": "  Jamie R  "})).await;
+        assert_eq!(status, StatusCode::OK, "{trimmed}");
+        assert_eq!(trimmed["name"], "Jamie R", "{trimmed}");
+    }
+
+    /// An id that names nobody is a `404` on both verbs, rather than a detail
+    /// view of a teammate that does not exist or a write that lands nowhere.
+    #[tokio::test]
+    async fn an_unknown_teammate_is_not_found() {
+        let home_dir = home();
+        let state = state_with_manifest(home_dir.path(), ROSTER).await;
+
+        let (status, _) = get_agent(&state, "nobody").await;
+        assert_eq!(status, StatusCode::NOT_FOUND);
+
+        let (status, _) = patch_agent(&state, "nobody", json!({"role": "Ghost"})).await;
+        assert_eq!(status, StatusCode::NOT_FOUND);
+    }
+}