Building a cognitive agent that actually remembers takes more than a good prompt. It needs a defined role, the right connectors, a memory engine that holds context between sessions, and a schedule that lets it act without being asked.

Most guides describe this in the abstract. This one does not. We are going to build one real agent from start to finish: a Meeting Prep and Follow-Through agent that connects your meeting notes to a Living Brain, then prepares follow-up emails, project tasks, team updates and meeting-ready documents from the same approved context.

Every stage below is the same checklist you would use to build any custom cognitive agent on ChatChat. We are showing you exactly how it plays out for one working example, so you can see what each step actually produces rather than imagining it.

Key Takeaways

A cognitive agent architecture needs four parts: a defined role, connectors to your real data, a memory engine, and a proactive schedule.
This guide builds one real example throughout: a Meeting Prep and Follow-Through agent connected to Gmail, Jira, Slack, Google Docs and Google Slides, with Granola or Gemini as its meeting capture source.
The Living Brain is what turns a single meeting into context that carries forward, connecting new notes to prior decisions, commitments and project history.
Everything this agent prepares stays in draft until you review and approve it. Nothing is sent or scheduled without your say-so.
The same five-stage checklist, role, connectors, memory, skills, scheduling, applies whether you are building a meeting agent, a research agent, or anything else on ChatChat.

What is a cognitive agent architecture?

A cognitive agent architecture is what separates an agent that remembers from one that resets every time you open a new chat. It has four parts: a role that defines what the agent is actually for, connectors that give it access to your real data, a memory engine that holds context between sessions, and a schedule that lets it act before you ask. The clearest way to see how these four parts fit together is to build one. So that is what the rest of this guide does.

Stage one: Define the agent's role

Every agent starts with a specific job, not a general purpose. For this example, the job is meeting follow-through: prepare a grounded brief before a call, then turn what actually happened into the next set of actions once it ends.

You can build this from the Agent Store's Chief of Staff template and narrow its focus, or describe the role directly: an agent that reads meeting notes, checks them against everything it already knows about the project and the people in the room, and prepares the follow-up work rather than just summarising the call.

That distinction matters. A meeting summary tells you what was said. This agent's job is to tell you what changed, what it affects, and what needs to happen next.

Stage two: Choose its connectors

Connectors are how an agent reaches your real data instead of working from what you type into a single conversation. Each agent gets up to six. This one uses five, which leaves room to add a sixth later if the role expands.

Gmail: Drafts the follow-up email, addressed and worded for its specific recipient.
Jira: Creates the tasks the meeting produced, with an owner and a date attached to each one, not a flat list.
Slack: Drafts a team update, written for the channel it is going to rather than a copy of the email.
Google Docs: Prepares a source-linked brief of the meeting, so every claim in it traces back to where it came from.
Google Slides: Turns the same brief into a presentation, when the audience is a meeting rather than a document.

Granola or Gemini sits alongside these as the agent's capture source, the approved notes, transcript or recording that becomes the factual record of what was actually discussed.

Stage three: Initialize its Living Brain

A connector gives an agent access to a tool. The Living Brain is what gives it memory of everything that has happened in that tool over time. Without it, every meeting note arrives as an isolated event. With it, a new note connects to the project's actual history the moment it lands.

For this agent, that history is the previous meetings, the documents already in play, the people involved, the decisions already made, and the commitments still open. When a new meeting note arrives, the agent checks it against all of that rather than reading it in isolation.

The Living Brain tracks two scores for everything it holds: freshness, how recently a piece of information was updated, and readiness, how usable it is for a given task. Together they stop an agent from working from something stale without knowing it.

Stage four: Select its skills

Connectors and memory give an agent access and context. Skills give it the specific ability to do something with them. From the Skills Marketplace, this agent needs document skills for building the Google Docs brief and the Google Slides deck, so the same narrative can be read as a page or presented as a room, without being written twice.

Skills are where you extend an agent beyond what it does out of the box. A different role would need different ones, a research agent might need summarisation skills instead, a sales agent might need CRM-specific skills. The point of this stage is to match the skill to the actual output the role needs to produce.

Stage five: Configure proactive scheduling

The first four stages give an agent everything it needs to do the work. Scheduling is what lets it start the work without you asking. For this agent, that means triggering the moment an approved meeting note lands from Granola or Gemini, rather than waiting for you to open a chat and ask for a summary.

You can also add a standing schedule alongside that trigger, a daily check for any meeting on the calendar that needs a prep brief before it starts. Either way, updates arrive as a notification, desktop or Telegram, rather than something you have to remember to go and check for.

What changes once it is running

The clearest way to see the difference is to compare the same meeting handled two ways.

Without this agent

Open the notes and reconstruct the wider history by hand.
Work out what changed since the last meeting yourself.
Draft the follow-up email from scratch.
Recreate the same actions again inside Jira.
Write a separate update for Slack.
Rebuild the presentation narrative for whoever needs slides.
Do the same reconstruction again before the next meeting.

With this agent

The new note connects automatically to previous decisions, people, commitments and project state.
The agent identifies what changed, why it matters, and what is now blocked.
A follow-up email is drafted, addressed to its recipient.
Jira tasks are drafted with an owner and a date attached to each.
A Slack update is drafted for its audience.
A source-linked Google Docs brief and a matching Google Slides deck are prepared from the same narrative.
Approved decisions carry into the next meeting automatically, so it does not start from zero either.

What this agent does not do
It prepares. It does not send. The email, the Jira tasks, the Slack update and the documents are drafted and held for your review. Nothing goes out and nothing gets scheduled until you approve it.
It only uses what you have connected and approved. An agent with five connectors sees five connectors' worth of data, nothing else.

Your next meeting shouldn’t start from zero

A useful meeting agent does more than summarise a call. It brings earlier decisions into the next conversation and turns new commitments into follow-up work you can review, without rebuilding the context each time.

Start with one clear job, connect the tools it needs, and give its Living Brain the approved knowledge to work from. Then choose its skills and schedule. As that history grows, your agent has more context to draw on, while you stay in control of what gets sent or scheduled.

Create your personalized agents at app.chatchat.com

How to build custom cognitive agents for persistent memory