# Give Your Coding Agents Your Engineering Judgment Save the decisions behind your system in Cortex. Your coding agents can retrieve them before they make a change. A Module stores current knowledge about one part of a system and why. Canonical page: https://socra.com/solutions/developers [Learn more about Cortex](https://socra.com/cortex) ## Your Agents Need the Reasons Behind Your System Your systems carry years of decisions about what matters and why. An agent that cannot see those reasons has to make assumptions. Save that knowledge in Cortex so your team’s agents can retrieve it before they change your system. ## Preserve Decisions as You Work Explain a constraint or correct a decision as you work. Your agent preserves the standard and its reason in Cortex, ready for the next task. ### Acme knowledge and dependencies Representative fictional product: Acme. #### 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. [Modules and dependencies](https://workspace.socra.com/docs/cortex/concepts/modules-and-map) ## Start Each Change with Your Team’s Standards Ask your agents to retrieve the relevant standards before changing code. You still review and test the result. A Flash returns the Module and the knowledge it depends on. ## 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) [Flashing your standard](https://workspace.socra.com/docs/cortex/concepts/flashing-context) ## Share Your Judgment Across the Team Give your team access to the decisions and reasons it needs. Authorized people and agents can retrieve the same maintained knowledge. ### 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. [Sharing access to knowledge](https://workspace.socra.com/docs/cortex/administration/access-and-permissions) ## Connect Your Coding Agent Connect an agent you already use, then retrieve knowledge when your work needs it. [Get started](https://admin.socra.com/login?intent=create) [Get started with Cortex](https://workspace.socra.com/docs/cortex/get-started/first-workflow)