An AI assistant is only as useful as the context it can see. That premise shapes a practical blueprint for turning Claude Code, Anthropic's locally installed agent application, into an AI chief of staff for a founder, agency owner or product leader. The surprising part is how little of the work is code. Most of it is information design: deciding where the company's rules live, where its customer records live, where its decisions get remembered, and how each of those sources plugs into the model. Once that structure exists, repetitive executive work such as morning planning, inbox triage, meeting prep, team updates and sales quotes can be handed over, with a person still holding the send button.
Why the setup starts with structure, not prompts
The architecture behind this approach splits the system into four parts:
| Layer | What it is | Examples |
|---|---|---|
| Desk | The interface where a person works with an agent harness | Claude Code (also Codex, Cursor and similar harnesses) |
| Brain | What the agent knows | Handbook, Records, Memory |
| Work | What the agent produces | Reusable Skills, on-demand Artifacts |
| Connectors | The cables between the agent and business apps | Notion, Gmail, HubSpot, Slack, Google Calendar |
Claude Code matters here because it runs as a desktop application on macOS or Windows rather than purely in the browser. In the cloud chat version of Claude, conversations, projects and execution state sit on Anthropic's servers. With Claude Code installed locally, sessions, execution history, custom skills and environment settings persist on the user's own machine. The desktop client exposes a session manager, customizable environments and integration toggles, which is where the rest of the blueprint lives.
The argument runs that even a very capable model stays operationally limited without well-structured context, and that popular autonomous agents cannot execute reliably over the long term without continuous, structured memory. That is why the Brain layer gets the most attention.
The three pillars of the Brain

▲ Handbook, Records and Memory layers
Pillar one: the Handbook
The Handbook holds durable company knowledge that human leadership writes and maintains, typically in Notion or Obsidian. It covers the mission, standard operating procedures, communication tone, pricing tiers and business constraints. The demo handbook includes explicit policies such as never negotiating below the standard pricing floor, ignoring unsolicited sales pitches, answering legitimate client messages within one business day, and requiring founder approval for any sponsorship above $3,000. It also forbids the agent from inventing prices, dates or customer statistics.
These rules do real work later. When a fictional sneaker brand offers $4,000 for a 60-second video integration, the agent checks it against the $3,000 threshold and flags it for explicit sign-off instead of answering on its own.
Pillar two: Records
Records are the structured, changing operational data: customers, deals, transactions. Non-technical founders can keep these in Google Sheets or a standard CRM such as HubSpot; technical teams can use developer databases like Supabase or AWS. In the demo, HubSpot holds a fictional streaming company's account with a $5,000 pilot deal at the appointment-scheduled stage.
Pillar three: Memory
Memory captures tactical decisions, past task resolutions and operational updates that the agent itself logs across many chats. In the demo this is an external, portable memory service added to Claude Code as a custom connector, with memory grouped under a project scope so the agent only searches the relevant folder. Shared memory of this kind lets multiple agents and teammates read the same organizational state across separate sessions and tools.
Connectors: the cable layer
Connectors in Claude Code are implementations of the Model Context Protocol (MCP), an open standard for feeding live data and tools into a model. The naming may appear to be a consumer-friendly label for what engineers would call MCP servers. The Connectors tab in the Customize menu shows active links to Google Drive, Slack, Google Calendar, Notion and Linear, and an "Add custom connector" dialog accepts a server name plus an HTTPS endpoint for anything not in the marketplace.
A status check in the demo environment lists 25 connected MCP servers across communication (Gmail, Slack, Google Calendar), documents (Notion, Google Docs), code (GitHub, AWS), design (Figma, Canva), CRM (HubSpot, Stripe) and shared memory. The Customize menu also lists prebuilt and community skills, such as a QuickBooks Labs bookkeeping skill, next to in-house ones.
Trust rules before any automation
Several guardrails are set before the agent touches live data:
- A dedicated project folder with a CLAUDE.md file that states behavioral limits. In the demo it restricts the agent to calendar items and emails carrying a "Demo" label and to Notion pages filed under "Chief of Staff," and it names the fictional test companies.
- The agent drafts; a human approves and sends. Autonomous output is a draft, not a dispatched message.
- Inbound email is treated as data, never as instructions. Text inside an external message must not be able to command the agent. The morning brief demo shows this in practice when a message posing as an urgent IT helpdesk request to forward invoices is flagged as a likely phishing attempt rather than acted on.
- Run a diagnostic prompt first. Asking Claude Code which tools it plans to query for a task, and why, before it makes any calls, exposes its reasoning and lets the user correct scope.
- Keep visibility on step-by-step execution, token use and context window consumption.
A related caution for non-technical leaders: make sure the CRM and handbook connectors are configured correctly before granting any autonomous email or update permissions.
Five jobs the agent can take on
The playbook organizes executive work into five jobs: Plan, Triage, Prepare, Align and Close.
Job 1: the morning brief
The agent builds a single-screen HTML briefing for the next day from Google Calendar, Gmail threads with the demo label and the "Monday scrum" page in Notion. Claude Code automatically engages an internal skill for morning briefings and runs calendar and email queries in parallel. The resulting artifact lists four decisions to make, five meeting preps and security warnings. Interactive artifacts like this are preferred over static slide decks because they can be rebuilt fresh each morning.
The workflow is then converted into a scheduled task that runs every weekday at 7:00 AM while the computer is awake. Claude Code generates the operational instructions, including source scopes and safety constraints, and the Scheduled Tasks sidebar offers a "Run now" button to trigger a headless background run that logs its actions. Built-in scheduling means no third-party automation tool is needed for the daily brief.

▲ Scheduled briefing and drafted proposal
Job 2: inbox triage
The agent reads unread threads, consults the Notion handbook, confirms that sponsorships above $3,000 need founder approval, and writes replies directly as Gmail drafts inside the existing threads, without sending. A draft to a prospective client's product ops lead outlines standard pilot terms and references the scheduled discovery call. The claim here is that an assistant with company-wide context produces noticeably better drafts than an email-only AI plugin, because it knows the pricing and the history.
Job 3: meeting prep
For an upcoming 30-minute catch-up with a venture capital partner, the agent runs memory search and recall against the project scope and returns a one-page brief: who the investor is, that she asked for weekly retention evidence, what the founder promised in return (three usage examples), the handbook rule against inventing metrics, and three questions to ask. Instructing the agent on how the executive thinks helps the prep focus on the right priorities.
Job 4: one page for people and agents
The agent drafts a weekly team update from the scrum doc and memory, with an explicit instruction not to invent unconfirmed progress. Output is grouped into Draft Team Update, What Is Blocked, Decisions Needed (for example, approving pilot pricing) and Decisions Recorded. Pricing parameters ($2,000 starter to $5,000 team plan) come straight from the handbook. The prep notes are then posted to a shared team board through a connector, and a teammate receives an automated notification.
Job 5: from quote request to CRM
An inbound email asks for a quote and pilot details for roughly 40 people. The agent reads the request, pulls the Notion price list, and writes a one-page PDF proposal with no invented terms:
| Item | Value from the handbook |
|---|---|
| Team pilot, up to 40 people | $5,000 for four weeks |
| Monthly upkeep after the pilot | $500 |
| Payment terms | Net 14 |
| Included | One kickoff call, weekly check-ins |
The first PDF looks plain. After being told to apply the company's design system, the agent reads stored design tokens and font files and regenerates a branded proposal with clean tables. Because the PDF does not attach itself to the open Gmail draft, the agent uses Computer Use, Anthropic's screen-control capability, to take screenshots, move the cursor and upload the file into the draft directly, a way to get past an API gap. It then calls HubSpot tools to verify the company record and log a note with the $5,000 proposal and the discovery call date, and finally writes the whole procedure into a Markdown skill file named quote-reply-and-crm.skill.md so identical requests can run the same way next time.
Bonus: Slack as the front door
With the Slack integration, teammates can mention @Claude in a channel and ask about a deal. The agent requests permission for its tools, queries HubSpot and Gmail history, and replies in the thread with a short status.
Caveats worth keeping in mind
Every company, calendar and deal in the demonstration is fictional and was built so the workflow could be shown safely, so the dollar figures are illustration, not benchmarks. Multi-step runs that search Notion and fetch email threads can show noticeable latency. And while hesitation about sharing email and calendars with AI persists, the observation offered is that founders and engineers increasingly treat connected context as standard practice; readers should weigh that for their own situation.
What to do with this
The repeatable lesson is that the agent's intelligence is bounded by the context you organize for it. A practical order of operations:
- Write the Handbook first: tone, SOPs, pricing floors, approval thresholds and a rule against inventing numbers.
- Put Records in a tool you already use, such as Google Sheets or HubSpot.
- Add a Memory layer the agent can write to and search across sessions.
- Connect each source through MCP connectors in Claude Code.
- Scope everything with a CLAUDE.md file and test labels; run a diagnostic prompt before live calls.
- Keep the agent in draft mode and reserve sending for a person.
- Once a workflow runs cleanly, save it as a skill and, if it recurs daily, schedule it.
Code-savvy teams can swap in developer databases and custom servers, but the structure is the same for everyone. Build the Brain carefully and the five jobs follow.


