# Stop Repeating Yourself to Your Agents Cortex lets you and your team share context across your AI agents, giving each agent the right knowledge before it acts. Canonical page: https://socra.com/cortex [Plugin (preferred)](https://cortex.socra.com/setup?method=plugin&step=agent) [CLI](https://cortex.socra.com/setup?method=cli&step=install-cli) [MCP](https://cortex.socra.com/setup?method=mcp&step=agent) ## Use Your Agents Exactly as You Already Do Connect through Cortex plugins, MCP or the Socra CLI. - [ChatGPT](https://workspace.socra.com/integrations/chatgpt) - [Claude](https://workspace.socra.com/integrations/claude) - [Claude Code](https://workspace.socra.com/integrations/claude-code) - [Codex](https://workspace.socra.com/integrations/codex) - [Cursor](https://workspace.socra.com/integrations/cursor) - [GitHub Copilot CLI](https://workspace.socra.com/integrations/github-copilot) - [Grok](https://workspace.socra.com/integrations/grok) ## Your Agents Need the Knowledge Behind Your Decisions Your systems carry decisions about what matters and why. When that knowledge is missing, agents have to make assumptions. Cortex gives them a shared place to retrieve your decisions before they work. [Specific knowledge](https://workspace.socra.com/docs/cortex/guides/turn-agents-into-experts) ## Give Your Agents Your Team’s Knowledge Before They Act Cortex gives agents your specific knowledge and its reasons before the work begins. ### Why not AGENTS.md? It has no import statement. A Cortex Module declares the knowledge it depends on, so a decision changed once reaches every agent that retrieves it, in every tool Cortex supports. [Agent Context Needs an Import Statement](https://workspace.socra.com/blog/engineering/agent-context-needs-an-import-statement) ### Acme knowledge and dependencies Representative fictional product: Acme. #### company Acme helps teams see how their work is going with dashboards and charts anyone can read. Teams use the platform to decide what to do next without waiting for a report. Every chart must lead back to the data it came from. When data is missing, the chart must say so instead of drawing a guess. Dependencies: None. #### product The platform is a web and phone app where each team builds dashboards and charts from its own data. It launched at 12:00 AM on Thursday, at $20 per seat per month. A chart must read the same on the web and on phones. A chart with missing data shows the gap; it cannot draw a flat line just because the rest of the dashboard loaded. Dependencies: company. #### id A person keeps one sign-in across the web app, phones and every team they join. Dashboards they built keep that identity after they leave a team. Store the name shown at the time alongside it so a later name change does not rewrite an old comment. Dependencies: product. #### id-auth A shared screen opens only the signed-in person’s dashboards. Switching people closes the previous person’s open dashboards, including unsaved edits. Each person signs in individually because a shared team login would make every change impossible to attribute. Dependencies: id. #### id-phones The phone app keeps the last dashboards a person opened readable without a connection. An expired session keeps those dashboards visible and shows when each chart last refreshed. Editing resumes only after the same person signs in again; handing the phone to someone else must not hand over their team. Dependencies: id-auth. #### id-recovery Account recovery restores the person’s existing sign-in, teams and dashboards. A new email address must not create a second person for the same teammate. Recovery signs out lost phones while keeping the authorship of every dashboard the person already built. Dependencies: id-auth. #### account An account belongs to one team and keeps its dashboards apart from every other team. A person on two teams chooses the team before opening a dashboard. Leaving a team does not move its dashboards or give the person’s new team access to them. Dependencies: id. #### account-access Removing a teammate ends their access to the team’s dashboards and scheduled exports. Check membership when a scheduled export starts and again before it sends a file. Keep the former teammate’s authorship so every dashboard they built still explains where it came from. Dependencies: account, id-auth. #### account-roles Roles decide who can edit a dashboard; everyone else on the team can view it. Changing someone’s role affects what they can do from now on. A dashboard keeps the name of each person who edited it, even after that person’s role changes. Dependencies: account. #### pricing A team pays $20 a month for each person with a seat; guests who only view dashboards are free. Teams average 1.5 seats, so the price must make sense for one or two people. A new seat takes effect that day. A guest cannot edit, build or export anything until the team gives them a seat. Dependencies: account-access. #### account-audit Every change to who can see a dashboard records who made it, when and which person it affected. Keep the record after the person leaves the team. A failed invitation remains a failed attempt; it must not appear in the record as access granted. Dependencies: account-access. #### project A project holds one team’s dashboards and the data behind their charts. Dashboards about the same work belong to one project, including copies made to try an idea. Splitting a team starts a separate project for the new team; earlier dashboards stay with the original one. Dependencies: account, product. #### project-access Project access governs every chart read, including exports and background refreshes. Resolve the project from the stored record and check the person’s current access. Cached charts and exported files keep the same project boundary as the data they came from. Dependencies: project, account-access. #### onboarding A new team’s first project opens with a sample dashboard, so the first chart appears in a minute. The sample uses example data and says so on every chart. Connecting real data replaces the sample without moving dashboards the team has already changed. Nobody is asked for a card before the first chart appears. Dependencies: project. #### dashboards A dashboard arranges a team’s charts and records who changed it last. Record the editor and time with every saved change. Restoring an earlier layout creates a new change linked to the one it replaces, so nothing silently disappears. Dependencies: project, account-roles. #### theme Every color the platform draws comes from the theme, never from a fixed value. The theme defines text, background and chart colors for light and dark. A new color enters the theme first; a color written straight into a screen or chart breaks the moment the theme changes. Dependencies: project. #### charts Every chart draws from the team’s data and reads the same on the web and phones. Keep drawing and data loading separate. A chart that is still loading says so, and a chart with no data shows an empty state instead of an empty axis. Dependencies: dashboards, id-phones, data. #### sample-charts The sample dashboard shows every chart type, so a new team sees what it can build. Each sample chart is labelled as example data. Changing a sample creates the team’s own copy; keep the original so the next new teammate still sees the full sample. Dependencies: charts, onboarding. #### chart-labels Chart labels, axes and legends use the theme’s text colors, never fixed ones. On launch night, labels stayed black on the dark background because charts used fixed colors. Fixing one chart would have hidden the cause; every chart now reads theme colors, and a test fails if one does not. Dependencies: charts, theme. #### chart-refresh A refresh shows each chart’s latest data once, even when a connection drops midway. Keep a stable refresh identity across retries. A chart updates only when all its data arrives. Two refreshes that disagree show the newer result and keep the time it was taken. Dependencies: charts, project-access. #### chart-checks Grace checks every chart type in light and dark, on the web and on phones. A chart that has not been checked stays out of the release. A failed check names the chart, the theme and the screen size, so Coda can find the cause instead of patching the symptom. Dependencies: sample-charts, chart-labels. #### data A team’s data stays in its project, and every chart cites the source it came from. A shared dashboard uses a fixed set of sources. New data enters on the next refresh and cannot silently change a chart that someone has already exported. Dependencies: project-access. #### data-history Keep each chart’s source data for as long as a dashboard shows it. A cleanup must account for every dashboard that cites a source before removing it. Previews may be regenerated, but a preview cannot stand in for missing source data. Dependencies: data. #### data-privacy Shared dashboards hide email addresses and other personal details in the team’s data. Hiding produces a separate view linked to the original data. If hiding a column would empty a chart, ask the editor to choose another chart. A release waits while any shared dashboard still shows personal details. Dependencies: data. #### search Search returns the exact dashboard and chart behind each match. Show the project and team so two similar charts are not confused. Results and cached matches obey current project access, including after a person loses access. Dependencies: data. #### requests Nina ranks requests by how many people asked, so Coda builds the most wanted one first. Each request cites what people actually wrote. On launch night, dark mode led with 214 asks, so it was built that night. A loud request from one person cannot outrank a quiet one from hundreds. Dependencies: data, product. #### feedback Feedback keeps each person’s own words, the screen they were on and the theme they used. A complaint about unreadable labels needs the screen and theme to reproduce it. When feedback is too vague to act on, ask the person one question instead of guessing what they meant. Dependencies: requests, data-history. #### roadmap The roadmap lists the next requests in order, with how many people asked for each. A request moves only when its count changes or Jordan decides otherwise. Each item links to the requests behind it. A guess about what people want stays a question, outside the roadmap. Dependencies: requests, search. #### contrast Text and chart colors keep readable contrast on light and dark backgrounds, in every chart type. Check contrast for every theme color pair, including labels and legends. Block a release that makes any text unreadable in either theme, even if every other check passes. Dependencies: requests, theme. #### dark-mode Dark mode follows each person’s system setting and takes every color from the theme. Coda shipped it with tests at 12:58 AM on launch night, after 214 people asked. A screen that ignores the setting is a bug. A color that stays fixed in dark mode goes back to the theme, never into a one-off override. Dependencies: requests, theme. #### bug-reports A bug report names the screen, what the person saw and the setting that made it happen. Grace separates what is visible from a suspected cause. Keep closed reports with their fix so the next person can tell a real cause from a symptom that was only hidden. Dependencies: dark-mode, feedback. #### release-signoff Grace’s sign-off covers one exact release and the checks she ran against it. Changing a screen or adding a chart requires another sign-off. Approval records who signed and when; a sign-off copied onto a later release approves nothing. Dependencies: dark-mode, account-audit. #### release-checklist A release lists what changed, what was tested on the web and phones and anything still unchecked. Every item must be accounted for before the release goes out. A known gap appears beside the screen it affects so nobody reads an untested screen as a tested one. Dependencies: dashboards, dark-mode. #### release-notes Release notes never change after they are sent; a correction goes out as a new note. Explain the correction and name the note it replaces. Keep the earlier note readable so the team can establish exactly what people were told. Dependencies: release-checklist. #### launch-day Launch day tells everyone at once, ships what people ask for and fixes causes, not symptoms. Maya tells everyone at once. Nina names the top request and Coda builds it; Grace tests it on the web and phones before it reaches everyone. Fix the cause, not the symptom. Morgan posts the numbers, and Jordan decides what’s next. Dependencies: release-notes, release-signoff, data-privacy, chart-refresh, project-access. #### waitlist The waitlist hears about each release first, at the same price everyone pays. Keep personal details out of every waitlist message. A corrected release note needs an explicit new send. Leaving the waitlist stops further emails but cannot recall one already read. Dependencies: release-notes, pricing. #### emails Emails and phone alerts link to a dashboard without showing any of the team’s data. Subjects and alert previews omit team names, numbers and charts. Opening the link checks current project access before showing the dashboard. Dependencies: project-access, product. #### support-playbook Priya answers each support request in plain words and names the fix when it ships. If the owner changes while a reply is queued, the new owner answers. Link to the current fix so an old reply cannot send someone to a workaround that is no longer needed. Dependencies: emails, dark-mode. #### welcome-email The welcome email goes out the moment someone signs up and names one first step. A retry keeps the same person and the same email. A failed send stays visible to the team for follow-up; it must not mark the person as welcomed. Dependencies: emails, waitlist. #### handoffs A handoff names what is finished, what was tested and who owns the next step, by name. A known gap counts as handed off only when the next owner has it. Untested changes and unexplained missing checks block the handoff. Work found after a handoff starts a linked follow-up. Dependencies: release-checklist, chart-checks. #### security Check the signed-in person and their team before reading or changing any dashboard. Resolve ownership from stored records. Background refreshes repeat the check before showing results. Removing access keeps the former teammate’s authorship without keeping their access. Dependencies: account, id-auth. #### testing Test team separation, phones and both themes before releasing the platform. Use two teams in access tests so a valid sign-in cannot read another team’s dashboards. Check every screen in light and dark, and verify that a dropped connection never shows a chart twice. Dependencies: account, product. #### architecture Keep project rules in one shared layer used by the web app, phones and background refreshes. The shared layer enforces project boundaries before anything reads or writes data. Keep network and storage details outside those rules so the phone app and the server apply the same decisions. Dependencies: project, security. #### coding-standards Use domain names, explicit errors and behavior tests when changing the platform. Name dashboards, charts and projects consistently. Take every color from the theme. Distinguish access denial from an unavailable connection. Add a regression test for the behavior being fixed. Dependencies: architecture, testing. ### Your Agent Captures the Knowledge As you explain, review and decide, your agent preserves useful knowledge and its reasons in Modules. You keep doing the work. ### Your Agent Connects the Knowledge The agent maintains the dependencies between related Modules. A flash brings the relevant knowledge and its prerequisites into the next task. ### The Agent Starts with Your Standard Before acting, the agent finds and flashes the narrowest relevant Module(s), bringing their prerequisite knowledge into the task. ### The Agent Checks the Current System The agent reads your reasons, verifies the current code and runtime, then works against your standard. You review whether the result follows your system. ### Your Knowledge Stays Current As requirements change, your agent updates the relevant knowledge and tells you why. Choose automatic updates or approval before changes are saved. [Modules and dependencies](https://workspace.socra.com/docs/cortex/concepts/modules-and-map) ## The Right Work Finds the Right Knowledge An Issue says what must change. Its Module says what must remain true. ### Issues Name the Standard Every Issue names its Module. The agent or teammate who picks it up can flash that Module before work starts. ### Dependencies Protect the Sequence Issues declare dependencies on other Issues. The inbox releases an Issue after all its dependencies close. ### Only Ready Work Reaches You The inbox shows released, unclosed work assigned to you. [Issues and coordinated work](https://workspace.socra.com/docs/cortex/concepts/issues-and-coordination) ## See What Cortex Returns This recorded CLI call retrieves a visit-report Module and its writing prerequisite. The example knowledge is fictional; the retrieval is real. `socra cortex flash example-fieldnote-visit-report` Cortex CLI · 2 Modules · 163 tokens > Fieldnote visit reports use sentence-case titles and plain language. Explain unfamiliar terms on first use, so a colleague who did not attend can understand the report. > A visit report names the visit’s date and location, separates direct observations from interpretations and ends with the next action and its owner. Keep that distinction because a later reader needs to know what was observed and what still needs checking. [Read the complete returned bundle](https://socra.com/evidence/cortex/fieldnote-flash-2026-11-03.txt) [Connecting coding agents](https://workspace.socra.com/docs/cortex/integrations/coding-agents) ## Turing Machines for Intelligence Models can apply new knowledge without being retrained. Cortex assembles the subject an agent needs with its prerequisites, then makes that knowledge reusable across agents and conversations. Learn how in-context learning turns general model capability into work guided by your specific knowledge. [Read the article](https://workspace.socra.com/blog/engineering/turing-machines-for-intelligence) ## Stored Once, Served on Demand Your Modules live in the cloud as one graph: stored in your workspace, addressed by name and owned by you. People, CoAgents (AI teammates with their own identity) and the agents you connect flash the same source, each within the Module permissions they hold. ### Addressed by Name A Module is referenced by name from repositories and tools connected through Cortex. ### Private to Your Workspace Knowledge never moves to another workspace. No other workspace can read your Modules. ### Owned and Recorded Every Module has an owner. Modules and Issues record who changed what: a person, a CoAgent or a connected agent. [Flashing shared knowledge](https://workspace.socra.com/docs/cortex/concepts/flashing-context) ## From You to Your Whole Team Start alone and add members when you need them. ### One Workspace Your people, CoAgents, connected agents and Modules live in one workspace, and its knowledge never moves to another. ### One Shared Graph People, CoAgents and the agents you connect work from the same Modules, as their Module permissions allow. [Workspace access and permissions](https://workspace.socra.com/docs/cortex/administration/access-and-permissions) ## You Don’t Have to Write the Knowledge Base You don’t have to write Modules before you begin. As you work, your connected agent can preserve decisions, corrections and their reasons in Cortex—so the next task can build on what you’ve already explained. [Read the article](https://workspace.socra.com/blog/engineering/you-dont-have-to-write-the-knowledge-base) ## Agent Context Needs an Import Statement Apply modules, dependencies, and imports to agent context. Mike Morton explains the SemDAG architecture and how Cortex makes shared knowledge available across agents. [Read the article](https://workspace.socra.com/blog/engineering/agent-context-needs-an-import-statement) ## Connect the AI Tools You Already Use Connect your agent to Cortex so it can preserve your decisions and use them in future work. [Get started](https://admin.socra.com/login?intent=create) [Get started with Cortex](https://workspace.socra.com/docs/cortex/get-started/first-workflow)