# How to build company context with Ambience

Published: 2026-06-07

Company context is not a transcript archive or a wiki dump. It is the current, source-linked, permissioned memory an AI agent needs before it acts.

Ambience is built for that layer. It turns calls, tickets, PRs, docs, Slack threads, local work, and agent sessions into typed memories with source, scope, redaction status, conflict review, and audit evidence.

## The short version

To build company context with Ambience:

1. Start with sources your agents already reach: Granola, Linear, GitHub, Slack, Google Docs, Notion, local repositories, and agent sessions.
2. Run a permissioned app sweep and ask the user which sources may be included.
3. Propose durable memories rather than saving entire transcripts.
4. Save only decisions, patterns, skills, conventions, failures, and references.
5. Attach source, scope, type, redaction status, and audit evidence.
6. Load relevant Ambience memories at session start and save durable takeaways at session end.
7. Review conflicts, stale memories, and scope changes every week.

## What you are building

Company context is the governed memory layer between approved AI agents and the work a business has already done. It tells an agent what the team decided, what constraints matter, which conventions are current, and where the evidence lives.

The goal is not to save every call, document, ticket, and transcript. The goal is to extract durable working knowledge with enough source, scope, and audit trail that future agents can safely rely on it.

Ambience gives that context a working form:

- Typed memories: decisions, patterns, skills, conventions, failures, and references.
- Source links: the call, issue, PR, doc, thread, or session that produced the memory.
- Scopes: personal, team, project, org, and sensitive.
- Redaction before storage.
- Conflict review for stale or contradictory context.
- Audit events for reads, writes, access changes, redaction outcomes, and conflict decisions.

## Start with sources your agents already reach

Most teams already have agents connected to tools like Granola, Linear, GitHub, Slack, Google Docs, Notion, local repositories, and files on their machine. Ambience can use those user-approved agent connections to propose source-linked memories instead of asking for broad credentials on day one.

That makes onboarding lighter and safer:

- The agent inspects available MCPs and local sources.
- The user sees which apps and sources are available.
- The user chooses what may be included.
- The agent proposes candidate memories with source and scope.
- The user approves, narrows, merges, or rejects each memory before it becomes durable.

Example sweep:

| Source | Available through agent access | Candidate memory | Scope |
| --- | --- | --- | --- |
| Granola | Meeting notes | Decision: launch onboarding uses permissioned app sweep. | Project |
| Linear | Issues and roadmap | Constraint: desktop routing must keep localhost preview stable. | Project |
| GitHub | PRs and repo | Convention: expose new workflows through UI, MCP, and CLI. | Team |
| Slack | Threads via agent access | Pattern: save durable decisions, not chat history. | Team |

## Choose the first durable memories

A durable memory should change future work. It should help an agent avoid a bad assumption, follow the team's current convention, or find the right source without rereading a whole transcript.

Save:

- A decision the team should follow later.
- A convention for how the team likes work to be done.
- A reusable implementation or operating pattern.
- A failure mode worth avoiding next time.
- A skill or workflow an agent can repeat.
- A reference source future agents should consult.

Skip:

- Meeting discussion that never resolved.
- Raw transcripts.
- Noisy status updates.
- Private opinions.
- Credentials, secrets, or unnecessary personal information.
- Large documents saved without a clear reason.

## Attach source, scope, and type

A memory becomes trustworthy when it carries provenance. This is the difference between "the agent remembered something" and "the team can see why this context exists."

Example Ambience memory:

Type: decision  
Title: Use a permissioned app sweep during onboarding  
Body: When a user installs Ambience, the agent inspects available MCPs and local sources, shows candidate apps, and asks what may be included before proposing memories.  
Scope: project  
Source: Granola call, onboarding review, June 2026  
Redaction: auto-redacted  
Tags: onboarding, company-context

Use project scope for delivery decisions, team scope for operating conventions, org scope for company-wide rules, personal scope for private preferences, and sensitive scope when access must be explicitly granted.

## Redact before storage

The safe boundary is before persistence. Secrets, credentials, private customer data, and unnecessary personal details should be stripped before a memory becomes durable company context.

Ambience treats redaction status as part of the memory record, so a future reviewer can see that sensitive text was handled without exposing the sensitive text again.

The core controls are:

- Source link: every accepted memory points back to the artifact that produced it.
- Scope: access is checked before retrieval.
- Redaction: sensitive text is stripped before durable storage.
- Audit: reads, writes, access changes, redaction outcomes, and conflict decisions become visible events.

## Seed the first context set

Pick one active project, one team, and one recent week of work. Ask the agent to propose 10 to 20 candidate memories from the approved sources, grouped by type and scope.

Approve only the memories that will help a future agent act better. Merge duplicates, narrow risky scopes, and link each accepted memory back to the call, ticket, PR, doc, thread, or session that produced it.

Good first memories often look like:

- Granola call -> product decision.
- Linear issue -> delivery constraint.
- GitHub PR -> engineering convention.
- Slack thread -> team operating rule.
- Google Doc -> reference memory.
- Agent session -> failure or pattern.

## Teach agents how to use it

The context only compounds if agents read and write it during real work.

At session start, load relevant Ambience memories. During work, search Ambience before making decisions. At the end, save durable takeaways with source, type, scope, and redaction state.

A useful team instruction is:

Before implementing, search Ambience for project decisions and conventions. After meaningful work, save only durable decisions, patterns, failures, skills, conventions, or references.

## Run a weekly context review

A weekly review keeps company context healthy.

Review should cover:

- Conflicts between memories.
- Stale context.
- Memories with scopes that are too broad.
- Personal notes that should become team or project context.
- Repeated workflows that should become skills.
- Source links that are missing or unclear.

The review should be short and evidence-based. If a memory cannot name its source, owner, or current scope, it should be corrected before agents depend on it.

## Measure the compounding effect

The right metrics are practical:

- Source-linked decisions reused by agents.
- Repeated questions avoided.
- Onboarding tasks that begin with the right project context.
- Risky memories scoped or redacted correctly.
- Conflicts resolved before stale context spreads.

Ambience makes this measurable because memory reads, writes, access changes, redaction outcomes, and conflict decisions are visible events rather than hidden prompt text.

## A 90-minute setup plan

0-15 minutes: install Ambience, connect the agent runtime, and confirm the user can view the memory dashboard.

15-35 minutes: let the agent inspect approved MCPs and local sources, then choose which apps are allowed for the first sweep.

35-60 minutes: approve only the decisions, conventions, patterns, failures, skills, and references that will help future work.

60-75 minutes: start a real agent session with the seeded context and verify the agent uses the right project decisions.

75-90 minutes: check source links, scopes, redaction status, and audit rows before expanding the sweep.

## Related Ambience pages

- [Company context for AI agents](https://ambience.sh/company-context)
- [Source-linked decision example](https://ambience.sh/examples/source-linked-decision)
- [How scoped memory works for teams](https://ambience.sh/writing/scoped-memory-for-teams)
- [Why redaction has to happen before storage](https://ambience.sh/writing/redaction-before-storage)
- [Ambience for Granola](https://ambience.sh/connections/granola)
- [Install Ambience](https://ambience.sh/install)

## Agent access

- Canonical page: https://ambience.sh/blog/build-company-context-with-ambience
- Markdown mirror: https://ambience.sh/blog/build-company-context-with-ambience.md
- Content index: https://ambience.sh/content-index.json