This is the film new users see when they first open onemind on a Mac. It shows three ways to work.

Work with your AI members. Mention an AI member in Matrix and give it a task. Another AI member can review the result.

Invite people and AI to your team. People and AI tools join as members, so everyone can see who is working on what.

Or keep using your own AI tools. Keep working in Claude Code, Cursor, Codex and the other tools you use. onemind shares their status and which Minds they used. Your prompts stay private.

You can watch the film again any time from Settings in the onemind app.

The problem

You correct an AI checklist that says a test passed when nobody ran it. Later, another tool makes the same claim. You fix the sentence again and explain the same problem to another teammate. The first correction stayed in one chat.

You want the next tool to follow the same reporting rule. Copying chats around makes that hard to manage. Teammates may miss the change or copy an older version. You need a shared rule you can read, approve and try on real work.

How onemind helps

A Mind holds your team's shared rules for AI tools. A Project is a folder of work, like one client or one product. You propose a change to that Project's Mind when a mistake keeps returning. Safe Check, an automatic check, checks the proposal before a person approves it. The approved rule can then reach connected tools set up for that Project folder.

An example

This is a made-up example to show how it works, not a real customer.

1. You ask Codex for a release-readiness checklist after changing a settings page. You ask for a change summary, checks performed and work still waiting for review. The draft says all checks passed. One test has not run, so you correct the checklist against the actual test results.

2. You propose a rule in the same Project's Mind. It says: report each check as run, not run or blocked. Only say it passed after seeing its result. Keep checks on your computer separate from results on the live app. Include the reason, leaving out private logs and passwords.

3. Safe Check checks your proposal. A teammate reads the change and any problems it finds. They check that the rule is clear, belongs to this Project and fits the team's other rules. You revise it if needed. Your teammate approves the rule; other work keeps using the current approved version until then.

4. You check each connected tool in that Project folder for Delivered and the new version. A sleeping computer may still be waiting for the update. Once the rule reaches Claude Code, you open a new chat with the tool in that folder.

5. You ask for another checklist after a follow-up settings fix. You give Claude Code the task and actual test results without repeating the rule. You say the browser check has not run. The answer should say so and avoid claiming it passed. You compare every claimed pass with the results you gave it.

6. You try the same rule in a new Cursor chat after its update arrives. If either tool overstates a result, correct the answer first. Then check the Project folder, tool setup and version. Keep the shared rule useful as your work changes.

How to know it worked

• The reporting rule shows as approved in onemind.
• Each connected tool shows the new version as Delivered for the right Project folder.
• In a new chat, the tool separates passed tests from tests nobody ran.
• You read the checklist and compare its claims with the actual results before using it.

What onemind doesn't do yet

• Automatic learning from finished tasks is coming. Today, you propose a change and a person approves it.
• Approval does not rewrite a chat you already have open. Start a new chat after the update reaches the tool.
• A tool can still miss a rule. onemind does not replace your own review.
• Updates need the right Project folder and tool setup. A computer must be awake and able to connect.

Read next

Read Stop repeating the same rules to every AI tool, Hand off AI tasks without losing the details and Keep each Project’s AI rules separate. For the steps in onemind, read Minds and review, Mind Sync and Sync activity.

Learn more

Follow Minds and review, Mind Sync and Sync activity to share your next correction. Pick a rule you can test in the next task.

The problem

You pass an AI task to a teammate, then spend another conversation explaining what happened. The first tool changed some files. A question stopped the work. Now someone must find the original request and work out which choices you accepted.

A copied chat can make that harder. Old ideas sit beside the current plan. A message saying the work is ready does not show whether your teammate can see the changes. You need a clear next step, the right files, and a way to find the person who must answer.

How onemind helps

Your Project is a folder of work, like one client or one product. Its Mind holds your team's shared rules for AI tools. Matrix is where your team sees AI tasks, their requests, and their latest results. Needs me is the list of things waiting for your answer. You can find a chat, continue it, or pass its latest result to another connected tool.

An example

This is a made-up example to show how it works, not a real customer.

1. You ask a developer using Claude Code to improve a saved-reports screen. When no reports exist, it should explain what to do next. Your approved Mind already says to reuse existing screen parts, support keyboard use, and include every supported language.

2. The developer checks that the rules show as Delivered for Claude Code in this Project's folder. They start a new chat with the tool. It prepares the change, but one question remains: should the button create a report or open the report library?

3. The developer leaves the latest result and that question on the Matrix task. You find the task through search or Needs me. You read the request and answer: open the report library. That choice stays with this task unless you separately propose it as a shared rule.

4. You can continue the original chat with Claude Code on the Mac that holds it. That Mac must be available. Instead, you choose a teammate using Codex to finish the task. Codex must be connected to the same Project, and any requested tool-owner approval must come first.

5. The developer writes a clear handoff: the chosen button action, the screen part already used, the remaining languages, and the checks needed. Codex starts from that last result. It cannot open Claude Code's full chat, so missing details need to be added before work continues.

6. The first developer uses Share changes so your teammate can read the code changes. Your teammate compares that copy with the working files before asking Codex to continue. You then review the screen, every language, keyboard use, and the checks that actually ran.

How to know it worked

• The shared rules show as approved, with Delivered for the receiving tool and Project folder.
• Your teammate can read the latest decision, open questions, and shared changes.
• The next result opens the report library and keeps the agreed screen rules.
• You review the result even when the task says Tool finished.

What onemind doesn't do yet

• A handoff passes the latest result, not the full chat. Continuing the original chat needs its Mac to be available.
• Code stays on its owner's Mac until they share changes. Later edits need another share.
• Automatic learning from finished tasks is coming. Pull-request and check status on Matrix tasks are also coming.
• onemind does not replace your own review. A tool can miss a rule or leave work unchecked.

Read next

Stop repeating the same rules to every AI tool, Fix an AI mistake once, for every tool, and Keep each Project’s AI rules separate. Read Matrix tasks, Matrix conversations, and Minds and review.

Learn more

Use Matrix tasks and Matrix conversations to try one handoff. Check what your teammate can read before asking them to continue.

The problem

You open an internal report and find wording meant for a client's booking product. Both products use AI tools, but their terms and screens differ. A useful rule was copied into someone's general tool settings. Now you have to find where it came from and check the rest of the work.

Switching folders should not mean rebuilding every instruction from memory. Yet your team keeps removing client names, changing screen references, and explaining exceptions. Shared rules also get lost along the way. You need a clear home for product rules and a separate place for rules that everyone follows.

How onemind helps

A Project is a folder of work, like one client or one product. A Mind holds your team's shared rules for AI tools. onemind combines approved team rules with the rules for your chosen Project and sends them to its folder. Safe Check, an automatic check, looks at proposed changes before you approve them.

An example

This is a made-up example to show how it works, not a real customer.

1. Your team maintains a client's booking product and an internal reporting product. Each has a separate local folder and Project. You need to add a message when someone leaves the booking date empty. The reporting product has different terms and uses different screen parts.

2. Your team Mind says to keep keyboard access, reuse existing screen parts, and review text that people will read. The booking Mind adds three rules. Use the word “booking,” use the existing field-error display, and keep anything the person entered when a form reports an error.

3. You check where those rules belong before approving them. Keyboard access matters to both products, so that stays with the team rules. Booking terms stay with the booking Project. You settle unclear or conflicting wording during review. Then you check that each Project points to its own folder and that the tools show Delivered.

4. You open a new chat with Claude Code in the booking folder. You ask for the missing-date message, the existing error display, and a keyboard check. You review the change yourself. The form should keep entered text, say “booking,” and make the error clear when someone uses only the keyboard.

5. The review reveals one missing detail. The form must also keep a selected date range, not just typed text. You propose that change to the booking Mind. Safe Check runs, a person reviews it, and you approve the wording. After it reaches the tools, you check it in a new chat.

6. Your next task uses Codex in the reporting folder. It should follow the team keyboard and reuse rules, plus the reporting product's own rules. Check its terms and screen parts. Updating the booking Project should leave the reporting Project's folder and rules as they were.

How to know it worked

• Each Project shows its own correct folder in onemind.
• The rules show as approved, and each needed tool shows Delivered for the right version.
• In a new chat, the tool preserves booking form entries and uses booking terms.
• A new chat in the reporting folder uses reporting terms, and you review both results.

What onemind doesn't do yet

• Choosing a folder does not send the rules by itself. A chat already open may keep older rules; check a new chat.
• Project rules stay in that Project's folder, outside general personal tool settings. Someone can still paste the wrong rules by hand.
• Automatic learning from finished tasks is coming. You still choose where a rule belongs and review the work yourself.

Read next

Read Stop repeating the same rules to every AI tool, Fix an AI mistake once, for every tool, and Hand off AI tasks without losing the details. For setup, see Projects and folders, Minds and review, and Mind Sync.

Learn more

Use Projects and folders, Minds and review, and Mind Sync to set up one Project. Check its next task before adding more.

The problem

You ask an AI tool to rewrite a client's pricing page. The draft sounds like another client. Now you must check every phrase, price and promise before you can judge the writing. Using several tools makes it harder to spot where the mix-up began.

You also keep explaining the same agency standards. A new editor needs the latest voice notes, the right files and a clear task. Copying an old brief feels convenient, but it can bring another client's words into the work. You need a clearer starting point for each client.

How onemind helps

A Mind holds your team's shared rules for AI tools, such as checking facts and asking about missing information. A Project is a folder of work, like one client or one product. Keep general agency habits in a shared Mind and each client's voice in their own Project Mind. You review proposed rule changes after Safe Check, an automatic check, before you approve them.

What it can save

Finding client details in the wrong place and fixing them takes time from your team's work. Say 4 people each lose about 20 minutes a week on these checks and fixes. That is about 6 hours a month, worth about US$350 at US$60 an hour.

4 people × 20 minutes ÷ 60 × 52 ÷ 12 ≈ 6 hours a month.

This is an example estimate, not a measured result. Use your own team's numbers. Try them in Solutions on the onemind homepage.

You still need to read results, so some time shifts to a quicker check rather than disappearing.

An example

This is a made-up example to show how it works, not a real customer.

1. You prepare two Projects: Client A website and Client B app. Client A's folder holds the website, content/pricing.md and brand/voice.md. Its Client A voice Mind asks for direct, restrained writing and approved product names. Client B has different files and voice rules.

2. You keep an Agency basics Mind for shared working habits. It asks tools to use supplied facts, flag gaps, write clear accessible text and leave client-facing changes for human review. It contains no private client briefs, offers or account details. A freelancer works only on Client A; you check their access separately.

3. Connect Codex, Claude Code and Cursor to Client A’s folder. Your editor checks that Claude Code shows Delivered for the agency and Client A rules. They open a new chat in the Client A website folder. You ask them to rewrite content/pricing.md, keep the existing prices and explain each plan. They must flag anything the files do not explain.

4. Claude Code drafts the changes. Your editor compares them with the price table, features and voice notes. A missing trial condition should become a question, not an invented offer. They also check for Client B's wording. Teammates see local file changes only after the owner shares a copy; later edits need another share.

5. Your reviewer reads the changed file and asks you about the trial condition. They also notice that Client A's rules do not say whether to call an account a workspace. Your editor proposes that clarification for Client A's Mind. Safe Check checks it, then you read and approve the wording.

6. Once Codex shows Delivered for the new Client A rules, the next editor starts a new chat for another page. They check whether it uses the agreed word. Client B's Mind and the shared agency Mind keep their own rules. The new page still needs its own facts and review.

How to know it worked

• Client A's new wording shows as approved in onemind.
• Each tool you use shows Delivered for the right client rules.
• In a new chat, the tool uses Client A's words and keeps the supplied prices.
• You read the changed file before you accept the copy.

What onemind doesn't do yet

• Separate Projects do not guarantee who can access client information. Check membership, file sharing and what people put in prompts.
• Delivered does not guarantee that every rule was followed. An open chat may keep older rules. onemind does not replace your own review.
• Automatic learning from finished tasks is coming. Fixing a draft today does not change a Mind; you still propose and approve rule changes.

Read next

Read Keep each Project’s AI rules separate and Hand off AI tasks without losing the details. Use Projects and folders, Team and Minds and review for the setup.

Learn more

Use Projects and folders, Team and Minds and review to set up one client first. Check the folder, people and rules before you share client material.

The problem

You ask AI tools to turn your catalogue into product pages. One draft shortens a product name. Another puts inches before centimetres. A third promises an arrival date you never agreed to. You spend the review fixing familiar mistakes instead of checking the products.

The same work starts again with the next range. Someone searches an old chat for your naming rules. Someone else pastes them into Cursor. A teammate explains them again to Claude Code. Fixing one page helps that page, but it does not teach every tool your rules.

How onemind helps

A Mind holds your team's shared rules for AI tools. Keep Store Standards for the whole team and Product page rules for the Online shop. A Project is a folder of work, like one client or one product. Use your local Online shop folder, with catalogue.csv, images, market notes and drafts. Safe Check is an automatic check for proposed rules; you review its findings before approving them.

What it can save

Checking product names, sizes and promises takes time. Say 3 people each lose about 45 minutes a week to those fixes. That is about 10 hours a month, worth about US$590 at US$60 an hour.

3 people × 45 minutes ÷ 60 × 52 ÷ 12 ≈ 10 hours a month.

This is an example estimate, not a measured result. Use your own team's numbers. You can try them in the Solutions section on the onemind homepage.

onemind does not remove the need to read results, so some time becomes a quicker check instead of disappearing.

An example

This is a made-up example to show how it works, not a real customer.

1. You prepare the autumn range in the Online shop folder. Store Standards sets the team's review expectations. The Product page rules Mind sets this store's writing rules. Codex, Claude Code and Cursor use the team rules alongside the rules for this Project. Other Projects keep their own product rules.

2. You agree the details before writing. Keep catalogue names intact and show dimensions in cm first. Never promise an arrival date or call a product “best”. Describe what an image shows in its alt text, the description read aloud by screen readers. Leave prices, stock and shipping facts in the source files.

3. You check that each connected tool shows the approved version as Delivered. Then you open a new chat with Claude Code in the Online shop folder. Ask it to write autumn product pages from catalogue.csv, using the market folders and images. Ask it to flag missing facts for you.

4. You compare each draft with its catalogue row and image. A folded throw needs a clear description, without sales language. Missing material or size details stay as questions. A market reviewer checks natural wording, units and claims. You also check the displayed page and whether each image has the right description.

5. You spot sales wording in an image description and fix the page. You also propose a clearer rule for the Product page rules Mind. Review the Safe Check findings and approve the change before sharing it with the tools. A page edit alone does not change the Mind.

6. For the next range, you check Delivered and open a new chat with Codex in the Online shop folder. Give it the new catalogue and markets. Check that it follows the updated image rule. You can reuse the agreed rules while still checking the new products.

How to know it worked

• The Product page rules Mind shows as approved in onemind.
• Each connected tool shows the right version as Delivered.
• In a new chat, names, units and image descriptions follow your rules.
• You check every market's pages against the catalogue before using them.

What onemind doesn't do yet

• Automatic learning from finished tasks is coming. Today, you propose and approve changes to shared rules.
• onemind does not replace your own review. Safe Check does not verify product facts or translations.
• A Mind does not provide live stock or shipping estimates. onemind does not put these pages on your shop.
• Delivered does not mean an open chat reread the rules. Start a new chat and check its work.

Read next

Read Stop repeating the same rules to every AI tool and Fix an AI mistake once, for every tool. For setup, see Minds and review, Mind Sync and Files and skills.

Learn more

Use Minds and review and Mind Sync to agree your rules and check they reach your tools. Files and skills explains how to keep the files for your work together.

The problem

You correct an invented fee in one AI draft. The next draft repeats it in another tool. You explain the rule again. Your team must find the right fee table and identify the product.

Different products make this harder. A fee that belongs on one page can slip into another. You need a clear place for each product’s rules. Check the finished words yourself. A smooth sentence can contain the wrong amount.

How onemind helps

A Mind holds your team's shared rules for AI tools. A Project is a folder of work, like one client or one product. Keep common writing rules in a Team Mind, and each product’s fee rules in its own Project Mind. Connect Codex, Claude Code and Cursor to the right local folders. Your team chooses an administrator to review fee rules before approval.

What it can save

Finding who approved an AI rule takes time away from checking financial content. Say 4 people each lose about 40 minutes a week finding which AI rule was approved, and by whom. That is about 12 hours a month, worth about US$690 at US$60 an hour.

4 people × 40 minutes ÷ 60 × 52 ÷ 12 ≈ 12 hours a month.

This is an example estimate, not a measured result. Use your own team's numbers. You can try them in the Solutions section on the onemind homepage. You still need to read results, so some time goes to a quicker check instead of disappearing.

An example

This is a made-up example to show how it works, not a real customer.

1. You set up a Help centre Project for the documents in work/help-centre/. A second product uses a separate Project and folder. The Team Mind says to preserve source wording and flag missing details. It also says to keep customer secrets and passwords out of Minds and prompts.

2. You find an estimated charge in a draft of docs/fees.md. You correct the draft and suggest a rule for the Help centre rules Mind: “Quote fees exactly from reference/fee-schedule.md. Never estimate.” The help page explains fees; the fee table supplies the amounts. A missing amount should become a question.

3. Safe Check, an automatic check, looks at your proposed rule before a person approves it. Your administrator reads the change, source path and check’s findings. They confirm which product it belongs to and address any problems. The current approved rule stays in place while they review.

4. After approval, you check Codex, Claude Code and Cursor for Delivered. Check the version and Project folder for each tool. Then open a new chat with Claude Code in work/help-centre/. An approval alone does not show that every tool has received the change.

5. You ask: “Update docs/fees.md from reference/fee-schedule.md. Keep the fee descriptions and amounts exactly as written. List anything the table does not answer.” Read the draft against the table. Check that another product’s terms have not slipped in.

6. You inspect the changed file and the page as readers will see it. Check that the fee table is current. Keep unanswered questions for your reviewer. Follow your team’s usual checks before deciding whether the page can go live.

7. Next, a teammate updates the related FAQ in a new chat with Codex in the same folder. They check for Delivered first. They still compare the FAQ with the fee table. Changing the shared rule needs another proposal, automatic check and human approval.

How to know it worked

• The fee rule shows as approved in onemind for the right Project.
• Each selected tool shows Delivered for the new version and correct folder.
• In a new chat, the tool copies fees accurately and flags missing details.
• You compare the changed page with the current fee table before using it.

What onemind doesn't do yet

• Automatic learning from finished tasks is coming. Correcting a draft does not change your team’s shared rules.
• onemind does not replace your own review or compliance, legal or regulatory review.
• Old chats can keep older instructions. A tool must be connected and ready to receive changes.
• Keep customer secrets and passwords out of Minds and prompts. Project folders cannot stop someone pasting the wrong information.

Read next

Read Fix an AI mistake once, for every tool and Keep each Project’s AI rules separate. See Minds and review, Team administration and Projects and folders.

Learn more

Use Minds and review and Team administration to plan who checks each rule. Follow Projects and folders to set up one product first.

The problem

You hand over dialogue work, then explain the story again. Your teammate needs character voices, quest names and unfinished decisions. A chat summary can miss why you changed a line.

When you switch tools, which files did the first tool change? Your teammate needs the latest work and clear answers.

How onemind helps

A Project is a folder of work, like one client or one product. A Mind holds your team's shared rules for AI tools. Matrix is where your team sees AI tasks, questions and shared changes. Safe Check is an automatic check of a proposed rule before your team administrator approves it. You keep shared rules in Minds and chapter decisions with the task.

What it can save

Handing over game work takes time when you have to explain the task again. Say 4 people each lose about 30 minutes a week re-explaining a task when it changes hands. That is about 9 hours a month, worth about US$520 at US$60 an hour.

4 people × 30 minutes ÷ 60 × 52 ÷ 12 ≈ 9 hours a month.

This is an example estimate, not a measured result. Use your own team's numbers. You can try them in the Solutions section on the onemind homepage. You still need to read results, so some time goes to a quicker check instead of disappearing.

An example

This is a made-up example to show how it works, not a real customer.

1. You set up the Quest dialogue Project with the local folder holding dialogue/chapter-3.json and locales/ja/chapter-3.json. Your Team Mind says to keep line names and placeholders unchanged, and report checks actually run. Placeholders mark spaces for inserted words. Your Style and Lore Mind holds voices, quest names and questions to flag. Connect Codex and Cursor here; Claude Code can receive the same approved rules. Another game keeps its own rules.

2. Your translation reviewer creates “Update chapter 3 dialogue” in Matrix. The narrative designer owns the Mac and connected Codex tool. They open a new chat with Codex in this folder and supply the revised encounter notes. They request consistent voices, unchanged line names and placeholders, and a list of names needing review. Check that the approved rules show as Delivered first.

3. Codex finds conflicting quest names in the notes and Japanese file. It asks which to keep. The designer leaves the question in Matrix for the reviewer. Needs me is the list of things waiting for your answer; the reviewer finds the question there.

4. The owner selects Share changes before asking for review. Teammates cannot see local edits until they are shared. The reviewer finds the Project chat in Matrix and reads the shared files. They answer: keep the established Japanese name for this chapter, and leave the line names unchanged.

5. You could continue Codex on the original Mac if it is available. Instead, hand the task to Cursor for this Project, getting owner approval if requested. Cursor receives the previous result, not Codex's full chat. Include the naming decision, file paths and remaining checks. The next developer compares the shared copy with the working files before continuing.

6. The developer asks Cursor to finish the Japanese edits. A suitable reviewer reads the dialogue in context, checks names and placeholders, and reviews the check results. The owner shares later edits again. Answering a chapter question does not change the Mind. Shared rules need a separate proposal, Safe Check and approval.

How to know it worked

• The tools show the approved rules as Delivered for the Quest dialogue Project.
• The next result includes the answered question and remaining checks.
• After Tool finished, you inspect the shared files and check names, line names and placeholders.
• A reviewer checks the Japanese wording and the scene before you use it.

What onemind doesn't do yet

• Automatic learning from finished tasks is coming. You still propose shared rules yourself.
• Pull-request and check status on Matrix tasks is coming. Read the actual check results yourself.
• Shared rules do not guarantee correct dialogue or update an open chat. You decide story facts; onemind does not replace translation or game review.
• Share later edits again. Keep unreleased story details only in the rules and task files you intend to share.

Read next

Read Hand off AI tasks without losing the details and Stop repeating the same rules to every AI tool. See Matrix tasks, Matrix conversations and Matrix for the controls.

Learn more

Use Matrix tasks to follow the work and Matrix conversations to find its chat. Matrix explains how your team works together.

The problem

You fix a product name in one AI draft, then find the same mistake in another. The blog says one thing. The FAQ says another. You need to check the brief again and explain the wording to another writer.

The correction stays in that chat unless someone takes it further. Switching from Claude Code to Codex or Cursor can bring the old phrase back. Your team needs a shared rule, alongside the brief for each launch.

How onemind helps

A Mind holds your team's shared rules for AI tools. Your Brand voice Mind keeps approved names, tone and phrases to avoid. A Project is a folder of work, like one client or one product. Its own Mind keeps the launch audience, brief and file rules separate from your shared brand rules. Safe Check is an automatic check of a proposed change; a person reviews it before approval.

What it can save

You spend time making the same wording fix in each tool. Say 5 people each lose about 20 minutes a week to those fixes. That is about 7 hours a month, worth about US$430 at US$60 an hour.

5 people × 20 minutes ÷ 60 × 52 ÷ 12 ≈ 7 hours a month.

This is an example estimate, not a measured result. Use your own team's numbers. You can try them in the Solutions section on the onemind homepage.

onemind does not remove the need to read results, so some time becomes a quicker check instead of disappearing.

An example

This is a made-up example to show how it works, not a real customer.

1. You set up the Launch blog Project with your local content folder. It holds content/launch-post.md, content/faq.md and notes/feature-brief.md. Connect Claude Code, Codex and Cursor there. Keep shared wording in the Brand voice Mind. Keep this launch's audience and file rules in the Project Mind. Another launch keeps its own rules.

2. You ask Claude Code to draft content/launch-post.md from the feature brief. Ask it to explain how approved rules reach connected tools. The draft calls the feature “sync engine”. You check the brief and change that name to “Mind Sync”. You also check the surrounding paragraph for promises the brief does not support.

3. You fix the draft, then propose a separate Brand voice Mind change. Write: “Use Mind Sync as the feature name. Do not call it sync engine.” Explain why that wording matters. Leave private campaign details in the Project. You are choosing a rule to reuse; changing the draft alone does not change the Mind.

4. Safe Check checks the proposal. Your team administrator reads the change, the check results and the source brief. They resolve any problems before approving it. The approved rule can then reach the connected tools. Approval alone does not show that every tool has received it.

5. You check that each tool in the Launch blog Project shows the approved version as Delivered. Open a new chat with Codex in the same folder. Ask it to update content/faq.md from the brief. You do not paste the naming correction into the request again.

6. You read the FAQ and check that it says “Mind Sync”. Check its feature claims against the brief too. For the next draft in Cursor, check the version and open a new chat with the tool. You keep one shared naming rule, while still reviewing every draft.

How to know it worked

• The naming rule shows as approved in onemind.
• Each connected tool in the Launch blog Project shows that version as Delivered.
• In a new chat, the tool uses “Mind Sync” in the draft.
• You check the whole draft against the brief before using it.

What onemind doesn't do yet

• Automatic learning from finished tasks is coming. You still propose reusable rules yourself.
• Delivered does not promise correct writing or update a chat already open. Check the tool, folder, settings and device.
• onemind does not replace your review of facts, tone or claims. Keep private launch details out of shared brand rules.

Read next

Read Fix an AI mistake once, for every tool and Stop repeating the same rules to every AI tool. For setup, see Minds and review, Mind Sync and Sync activity.

Learn more

Use Minds and review to approve a rule, then check Mind Sync and Sync activity. Start with one product name that your team keeps correcting.

The problem

You ask an AI tool to change some code. At review, you find missing tests and no changelog entry. A teammate using another tool follows an older checklist. You explain the same standards again before either change is ready to use.

Your rules sit in old chats, personal notes and copied prompts. Everyone has a slightly different version. You want one set of agreed rules for routine work. You also need each product's names and test commands to stay with that product.

How onemind helps

A Mind holds your team's shared rules for AI tools. A Project is a folder of work, like one client or one product. Keep common rules in the Coding rules Mind and invoice details in the Billing app Project's Mind. Connect Codex, Claude Code and Cursor to get the approved rules in that folder. Before approval, use Safe Check, an automatic check, then read the proposed rules yourself.

What it can save

Repeating coding rules and fixing work that ignored them takes time from your team's work. Say 6 people each lose about 30 minutes a week on these tasks. That is about 13 hours a month, worth about US$780 at US$60 an hour.

6 people × 30 minutes ÷ 60 × 52 ÷ 12 ≈ 13 hours a month.

This is an example estimate, not a measured result. Use your own team's numbers. Try them in Solutions on the onemind homepage.

You still need to read results, so some time shifts to a quicker check rather than disappearing.

An example

This is a made-up example to show how it works, not a real customer.

1. Set up the Billing app Project with its code, tests and CHANGELOG.md in its local folder. The Coding rules Mind asks for tests, changelog entries for changes users see, no saved secrets and human review. The Project's Mind adds invoice names, existing endpoint patterns and test commands. Approve both after review.

2. Check that the approved versions reached Codex on your device in the Billing app folder. Start a new chat with the tool there. Ask it to add a CSV download to the invoices page. Name the columns you need and ask it to keep the existing access checks.

3. Read the proposed code, tests and changelog. Check column order, commas, line breaks and empty results. Check who can export invoices. Run the relevant tests and read their results. Say clearly which checks you have not run. Look for unrelated edits and accidentally saved secrets.

4. Fix anything missing from this change. If a rule needs clearer wording, propose a separate Mind change. Read the automatic check's findings and get a person's approval before sending the updated rule to tools. Finishing the coding task alone does not change the team's rules.

5. In Matrix, where your team sees AI tasks, use Share changes to let teammates read a copy. They cannot see your local code changes there before you share them. Share again after later edits. Your reviewer reads the code and test results before accepting the change.

6. For the next invoice task, check that the rules reached Claude Code or Cursor in the same folder. Start a new chat with that tool. Give it the new task's goal and checks. Read its result against the same standards; tools can follow the same rule differently.

How to know it worked

• The rules show as approved in onemind.
• Each selected tool shows the right version as Delivered for this folder and device.
• In a new chat, the tool includes the expected code, tests and changelog.
• You read the change and test results before you use it.

What onemind doesn't do yet

• A Mind does not run tests or approve code. Safe Check checks proposed rules; you still review the code yourself. Keep passwords and keys out of shared rules and task requests.
• An open chat may keep older rules. Check each tool and device, then start a new chat.
• Automatic learning from finished tasks is coming. You still propose and review changes to shared rules.
• Pull-request and check status on Matrix tasks is coming. Sharing changes lets teammates read a copy; later edits need another share.

Read next

Stop repeating the same rules to every AI tool · Fix an AI mistake once, for every tool · How to share AI instructions across Claude Code, Codex, and Cursor

Use onemind with Codex · Use onemind with Claude Code · Use onemind with Cursor · Mind Sync

Learn more

Use Use onemind with Codex, Use onemind with Claude Code and Use onemind with Cursor to set up your tools. Then follow Mind Sync to check one rule with a small coding task.

The problem

You explain the same writing rules every time someone changes AI tools. One teammate pastes an old copy into Claude Code. Another asks which version to use in Cursor. Before the work starts, you are already answering questions about the rules. Later, you still have to spot which instructions the draft missed.

Separate copies make a small change hard to follow. You fix the date format in one prompt, but another tool keeps using the old format. Your reviewer has to check the request, find the latest rules, and explain the correction again. The team needs a shared place to agree on those rules.

How onemind helps

A Mind holds your team's shared rules for AI tools. A Project is a folder of work, like one client or one product. You approve a rule, then onemind sends it to connected tools in the Project's chosen folder. Safe Check, an automatic check, looks at proposed rules before you decide.

An example

This is a made-up example to show how it works, not a real customer.

1. Your small product team needs a help page for an export feature. You want invented records in every example. Dates must use YYYY-MM-DD. The page must explain that requesting an export does not mean the download has finished. These rules should also apply to later help pages.

2. You write the rules in the product's Mind. A teammate reads them and checks what each sentence means. Safe Check runs before you approve the wording. You clear up anything confusing first, including when the page can say a file is ready. The approved version becomes the rule for future work.

3. You connect Codex, Claude Code, and Cursor to the product's local folder. You turn on sync for the tools you need. Each tool keeps its own way of reading instructions. onemind sends the same approved rules through those instructions, so you do not edit three separate copies.

4. After each tool shows Delivered for the new version, you open a new chat with Cursor in that folder. You ask for an export help page with an example and the steps after a request. You describe the current task without pasting the standing rules again.

5. You read the draft before using it. Check the invented records, the date, and the difference between requesting an export and finishing a download. If a rule is missing, correct the draft. Then check which rules reached Cursor, rather than assuming that a successful sync guarantees a correct answer.

6. A teammate later opens a new chat with Claude Code in the same folder. They ask it to update the export questions and answers. The approved rules should guide that task too. They still read the result and check the same details before the changes go into use.

How to know it worked

• The rule shows as approved in onemind.
• Each tool shows the new version as Delivered for the right Project.
• In a new chat, the draft follows the example, date, and download rules.
• You read the result before you use it.

What onemind doesn't do yet

• Sync needs the right tools, settings, and an available device. The browser can request sync; the local app writes the files. Open chats may keep older rules.
• A Mind does not move a tool's full chat history. Different tools can still answer differently. Project rules stay in that folder.
• Automatic learning from finished tasks is coming. Keep private details out of shared rules and review every result yourself.

Read next

Read How to share AI instructions across Claude Code, Codex, and Cursor, Fix an AI mistake once, for every tool, Hand off AI tasks without losing the details, and Keep each Project’s AI rules separate. For setup, see Minds and review, Mind Sync, and Projects and folders.

Learn more

Start with Minds and review and Mind Sync. Choose one rule, then check whether a new chat follows it.

Choose an AI memory tool by the work you need to finish: coordinate agents, give an application persistent context, or maintain instructions across the tools your team already uses. These needs overlap, but they require different evaluations.

onemind manages reviewed, versioned team and project guidance for supported AI tools. If you are comparing Raft, Mem0, Supermemory, Zep, Letta, Ruler or native tool memory, use the questions below to decide whether onemind fits your workflow.

This comparison is written by onemind. Competitor descriptions summarize the official sources linked below, checked on 22 September 2026. They are not a hands-on performance benchmark. Features and plans can change.

Compare the job, then the product

Considering a Raft alternative?

Raft already includes memory and review-oriented workflows. Do not choose on the assumption that only one product can support oversight. Walk through one real task: a teammate corrects an instruction, someone reviews it, and another agent uses the result. Compare setup effort, visibility of the active guidance, recovery from a wrong instruction, and the result of the later task.

onemind is worth evaluating when your recurring problem is maintaining approved guidance across existing tools. Check the supported integrations and current release limits before treating it as a replacement for an agent workspace.

Considering Mem0, Supermemory, Zep or Letta alternatives?

First distinguish application memory from team operating instructions. If you need a memory API inside a product, evaluate those products' developer interfaces directly. This page does not establish onemind as an API-compatible replacement. If your problem is that people using Codex, Claude Code and Cursor repeatedly correct the same project rule, start with a shared-instructions workflow.

When native files or rule-sync tools are enough

A small team can keep AGENTS.md, CLAUDE.md and Cursor rules in Git and review changes together. Ruler and ai-rules-sync are relevant when maintaining those files is the main job. Do not add a system unless its review, scope and maintenance workflow improves your actual work. A one-time format conversion does not provide ongoing synchronization, and tool-specific loading rules still apply.

Try the same task before switching

1. Choose a disposable project and a harmless rule: use YYYY-MM-DD dates in reports.
2. Record your current workflow's setup time and repeated corrections.
3. In onemind, review the rule, select its Project scope and sync to a supported connected tool.
4. Open a fresh related task in a second tool without repeating the rule. Inspect the output and the delivered version separately.
5. Change or remove the instruction, then check the next task and an unrelated project. Compare maintenance time and incorrect results.

This is an evaluation procedure, not a claim of measured improvement. A delivered file does not guarantee model compliance.

Read the shared-instructions walkthrough, follow the Mind Sync guide, or open onemind to evaluate one reviewed lesson.

Apple has introduced iPhone Duo, its first foldable iPhone. What interests us most is the care behind the experience: how an app uses the extra space, where its buttons go, and how your work carries on when you open or close the phone.

Apple has long published design guidelines to help people build apps for its devices. For iPhone Duo, there is also something you can hand straight to your AI agent: a Markdown version of the design guide. It puts Apple’s layout and interaction advice into a text file the agent can read and use while adapting your app. You and the agent can work from the same rules.

For us, this is also a good example of how to work with AI. Give it clear rules before it starts, then check the result against those rules. Fewer rounds of corrections can save time and reduce the tokens spent on rework.

Next, we’ll use Apple’s design guide to explore how to write good design rules for AI.

3. Three ways to put this into practice

Here are three everyday tasks where the same approach can help. Each starts with a short passage from Apple’s guide.

4. How does this relate to a Skill or a Mind?

Once an instruction works well, save it. A note called “How we translate announcements” could hold the languages you need, a few good examples, and reminders about mistakes you have already fixed.

A Skill is a way to give an AI tool instructions for a particular job. It can also include examples or files the tool needs. In a tool that supports Skills, your translation note could become part of a translation Skill.

onemind uses the word Mind for the knowledge, rules, skills, and experience you want AI to work with. That can include how your team likes to write and why certain details matter. For example: “Keep our delivery dates as written, because customers plan around them.”

Apple’s guide is a source you could use when creating a Skill for app design. You would still need to explain when the AI should use it and what to check.

Reading a longer guide also uses tokens. Keep the full reference available, then ask AI to find the parts needed for the task and check for relevant exceptions. Judge savings by the whole job, including reading, corrections and retries.

5. One more thing

Now you can use onemind to bring Apple’s iPhone Duo design guidelines into your team’s daily work, giving teammates and AI agents a shared set of rules.

For your iPhone Duo project, put a link to Apple’s original guide in a shared Mind.

For example, your designer, developer and AI reviewer could all work from one rule: “Keep entered text and the selected item when the layout changes.” The designer plans for it, the developer implements it, and the reviewer checks it. Each has a different job, with the same expectation for the result.

When you find a useful correction, add it to the Mind for review. Once approved, include it in the guidance for future work and check whether the next task gets it right. That’s how one lesson can help the whole team spend less time repeating corrections.

This is independent commentary by onemind. It is not sponsored or endorsed by Apple. Quoted material © Apple Inc. Apple and iPhone are trademarks of Apple Inc.

Keep shared instructions in a reviewed, version-controlled source, deliver them using each tool's supported format, and test the result in a new task. Copying a file is only the delivery step: the useful outcome is that the next task applies the right instruction.

Which file should each tool use?

• Codex: uses AGENTS.md instructions along its project path. More specific instructions and overrides can affect what it loads.
• Claude Code: uses CLAUDE.md for project instructions that a team can share through source control.
• Cursor: supports AGENTS.md for straightforward project guidance and .cursor/rules for more specific rules. Organization-level Team Rules are also available on its Team and Enterprise plans.

These mechanisms have different loading and scope rules. Keep tool-specific settings separate and check the official documentation linked below before changing an existing setup.

The main differences at a glance:

A minimal example

Write the rule once per tool and keep the wording identical, so a reviewer can compare the files line by line.

AGENTS.md for Codex, which Cursor also reads:

# Reports
- Write calendar dates as YYYY-MM-DD.
- If a date is ambiguous, ask before writing it.

CLAUDE.md for Claude Code:

# Reports
- Write calendar dates as YYYY-MM-DD.
- If a date is ambiguous, ask before writing it.

.cursor/rules/reports.mdc, a Cursor rule limited to report files:

---
description: Date format for project reports
globs: reports/**
alwaysApply: false
---
- Write calendar dates as YYYY-MM-DD.
- If a date is ambiguous, ask before writing it.

Commit all three files together and review changes to them as one change.

Start with one rule and one owner

In a disposable example project, write a small shared rule: “In this project's reports, write calendar dates as YYYY-MM-DD. Ask when a date is ambiguous.” Put the appropriate instruction in each tool's supported project file. Have one person review changes to the common rule together; do not overwrite an existing file or copy personal instructions into team guidance.

For a small team working in one repository, reviewed files in Git may be sufficient. Choose one authoritative source for shared text. If a script generates other files, label them as generated and review the source instead of editing both copies independently. Preserve each tool's required format and scope.

How do you know the instruction worked?

1. Confirm the intended project and instruction version reached each tool.
2. Start a separate task in that project. Ask for a report dated 14 September 2026 without repeating the formatting rule.
3. Inspect whether the result uses 2026-09-14. Save the task and rule version as evidence.
4. Test an ambiguous date and a different project. Check that the tool asks for clarification and that project-specific guidance has not spread to the wrong scope.

This is a suggested verification exercise, not a benchmark or a claim about guaranteed model behavior. A loaded file and a correct later response are separate observations. If the check fails, inspect the actual loaded instructions, conflicting rules, project scope, and tool version before adding more text.

A short review-to-handoff exercise

This extends the check above into one reviewed rule, one task, one handoff and one result check. It is a suggested exercise written from the current onemind documentation; it was not run against real providers for this revision, and the outcome depends on each tool's version and model behavior.

Use a disposable Project folder, no customer content, and the date rule above as the only shared rule. Use Claude Code and Codex for the task steps; Cursor is not offered for Matrix task assignment, so check it with the file steps only. Each task is a fresh task started after delivery, not the chat that wrote the rule.

1. Review. Propose the date rule as a change to a Mind in that Project and have a reviewer approve it. Note the approved version. See Minds and review.
2. Deliver. Sync the Mind to Claude Code's bound folder and wait until Sync activity shows Delivered for that tool and folder; Queued or Applying is not delivery. See Mind Sync.
3. First task. In Matrix, create a task in that Project such as “Write the weekly report in reports/weekly.md, dated 14 September 2026”, without repeating the rule, and assign it to Claude Code. If the tool asks for permission, only the owner of its Mac can answer.
4. Deliver to Codex, then hand off. When the task shows Tool finished, deliver the same approved Mind version to Codex's own bound Project folder and wait until Sync activity shows Delivered for Codex and that folder. A teammate's Mac has its own bound local folder, and Claude Code's receipt says nothing about Codex. If that delivery or its version is unknown, stop and fix it before continuing. A handoff passes the task and its latest result, not repository files and not Claude Code's full chat. Before Codex edits anything, the reviewed reports/weekly.md must already exist in Codex's own bound folder or worktree through your team's normal reviewed file or Git workflow; if it is missing, stop and reconcile it first. A finished task moves to another tool from the message box under its run; the task menu's Handoff only reassigns a task that is still assigned, working or blocked. Under Continue in, choose Codex connected to the same Project, and write the file path, the reviewed first line and any decisions Codex needs into that message. If Codex belongs to a teammate, their approval comes first and the task shows Awaiting approval. In the same message, ask Codex to keep the reviewed first line of reports/weekly.md and add a line dated 21 September 2026, without repeating the rule. See Matrix conversations.
5. Check the result. Open the task's Changes tab to read the diff; the tool owner uses Share changes so teammates read the same snapshot. On the Mac that ran the tool, Terminal shows the run output and Preview can show a local development server; other machines see only shared changes. Record the task, both results and the Mind version.

It worked if

• Sync activity showed Delivered for each tool's own bound folder before that tool's task started.
• Claude Code's first result in reports/weekly.md uses 2026-09-14. Codex's handoff result keeps that reviewed first line and adds 2026-09-21. Neither task prompt repeated the formatting instruction.
• Task logs show Handoff to Codex.
• A teammate who owns neither Mac can read the shared changes and the task logs.
• A person reviewed the output. A finished run means the tool reported finishing, not that the work is accepted.

Treat it as failed if

• Either tool writes another date format or asks for the rule. Before adding text, check the approved version, the sync status for that tool and folder, whether the task ran in the bound folder, conflicting local files such as CLAUDE.md imports or .cursor/rules, and the tool version.
• Codex relies on a decision that existed only in Claude Code's chat. Add it to the handoff and run again; this is expected behavior, not a defect.
• The run shows Blocked or Failed, waits for a device, or Codex is missing from Continue in. Check that the Mac is online and signed in and that Codex is connected to the same Project, reassign if it stays offline, and read the task states that allow a handoff in Matrix tasks. An unanswered permission request expires and counts as declined.

Limits of this check. It observes one rule, two tools and one handoff; it does not measure how often tools follow instructions. Delivery, a correct result and later behavior are separate observations. If a Mac sleeps or onemind quits during a run, the tool owner receives a Run interrupted notice and can choose Resume; nothing resumes on its own. Recurring or scheduled runs are outside this exercise. For a fuller walkthrough, read Hand off AI tasks without losing the details.

Where does onemind fit?

onemind helps teams maintain reviewed, versioned instructions and lessons across AI tools. Use a Mind for the guidance you want to maintain, make the intended Team or Project scope explicit, and review a proposed correction before distribution. Then verify its use in a later task.

The useful difference to evaluate is whether the review and maintenance workflow reduces repeated corrections for your team. A file-based setup may already meet your needs. onemind does not guarantee that an AI model will follow every instruction; access controls and tests remain necessary.

Primary references

Tool behavior changes. Consult the current Codex instruction guide, Claude Code memory documentation, and Cursor rules documentation. This guide describes a workflow to evaluate, not a customer case study.

Your company bought ChatGPT subscriptions. Claude seats. Cursor licenses. Codex usage. API tokens.

Then you gave them to employees and said:

Use AI. Be more productive.

And, to some extent, it worked.

Developers wrote code faster. Designers explored more ideas. Product managers drafted specifications in minutes. Marketers produced more campaigns.

Everyone got a capable assistant.

But did the company become a more efficient organization—or did it simply buy more production capacity?

Those are not the same thing.

You gave AI to the people in your team. You didn’t necessarily make AI part of the team.

More output is not the same as more efficiency

Producing more work is valuable. But the goal of a company is not to produce as much code, documentation, or design as possible.

It is to turn coordinated effort into useful results.

Consider a team building a new feature.

The designer uses AI to update the interface. The developer uses AI to implement it. The marketer uses AI to prepare the launch.

Each person "finishes" their part faster.

But the developer’s AI follows an outdated design standard. The marketer’s AI describes a capability that was removed from the plan. And the designer’s AI proposes an interaction the team already rejected for technical reasons.

Now the team has to reconcile everything.

More review. More explanations. More revisions. More time. More token. More costs.

The individual tasks became faster. The work between those tasks did not.

You can improve the speed of every contributor without fixing the friction between them.

That is the gap an AI subscription alone does not close.

The AI is connected to the employee, not the team

Look at the structure behind this kind of deployment.

A developer opens Codex. A designer talks to Claude. A product manager uses ChatGPT. A marketer starts another conversation somewhere else.

Each AI may have useful context. But that context depends on what its human provides, what its tool can access, and whether that information is current.

The developer’s AI knows the architecture. The designer’s AI knows the visual guidelines. The product manager’s AI knows why a feature was rejected. The marketer’s AI knows the latest positioning.

But these pieces of knowledge do not automatically become shared team knowledge.

When a decision changes, who makes sure the relevant AIs receive it?

When someone discovers a constraint, who carries it into everyone else’s tools?

When a new person joins, who reconstructs the context their AI needs?

Too often, the answer is: the human behind each AI.

The employee becomes the connection between their assistant and the organization. They copy decisions into prompts, update local instructions, attach documents, and explain what changed.

The AI can help with the work. But its human still has to carry the team’s memory into the conversation.

The biggest mistake: buying intelligence without integrating it

Imagine hiring an engineer, giving them a powerful computer, and immediately assigning work.

You never introduce them to the team’s goals. You do not explain the architecture, provide the current standards, or show them which approaches have already failed.

Whenever they need context, someone gives them a few fragments.

When they make a mistake, you explain the missing information.

Then, on the next assignment, you repeat the process.

You would not call that engineer properly onboarded.

Yet an AI deployment can end up working exactly this way.

Access is treated as onboarding. A subscription is treated as integration.

But giving someone a tool is not the same as giving that tool a working relationship with the organization.

Employees who already understand the company can compensate. They know which instructions to provide, which documents matter, and when an answer conflicts with an earlier decision.

New employees cannot reliably supply context they do not yet have.

Instead of making organizational knowledge easier to use, the deployment can preserve the same old dependency: your AI is only as informed as the person responsible for keeping it informed.

More tokens cannot fix a missing connection

A stronger model may reason better. More tokens may let it do more work. A larger context window may let it consider more information.

Those improvements matter.

But none of them, by itself, tells the AI that the team changed a requirement yesterday.

A larger context window is not a process for keeping context current.

A longer-running agent is not a mechanism for coordinating with other contributors.

And another subscription is not shared organizational memory.

If the missing ingredient is a team decision, more reasoning over outdated information does not supply it.

The question is not just:

How much intelligence can we afford?

It is also:

How does that intelligence learn what our team knows—and stay aligned as that knowledge changes?

Until there is a reliable answer, increasing AI capacity leaves the underlying coordination problem unresolved.

What makes an AI a teammate?

Calling an AI a teammate does not require pretending it is human. It does not mean giving it unrestricted access or letting it make every decision.

It means integrating its work into the team’s shared goals, knowledge, and responsibilities.

That requires more than a good prompt.

A shared starting point.
The AI should have access to the relevant project goals, standards, constraints, and approved decisions—not depend on someone remembering to include them in every task.

Continuity.
The team should not lose important context when a conversation ends, a contributor changes tools, or another AI takes over. The work should continue from what the team has already learned.

Clear responsibilities and boundaries.
The AI needs to understand its task, what it may access or change, when approval is required, and what a completed handoff should contain. Being part of the team does not mean knowing everything or acting without oversight.

A way to contribute back.
An AI may discover a useful constraint, identify an outdated rule, or propose a better approach. That contribution should be available for review and, when approved, become part of the team’s shared knowledge. A suggestion should not silently become company policy.

Shared context is not the whole of teamwork. But it is a foundation for making responsibilities, review, and coordination work.

The human should still direct and evaluate the AI’s work.

They should not have to act as a manual synchronization service between every conversation and the rest of the company.

From personal intelligence to organizational intelligence

Giving every employee an assistant addresses one question:

How can this person work better?

An AI-native organization must also address another:

How can humans and AIs work better together?

The first question leads to better individual tools.

The second requires shared organizational infrastructure.

Project context cannot live only in one person’s conversation. Decisions cannot remain useful only to the people who attended the meeting. Standards cannot depend entirely on someone remembering to copy the latest version into a local file.

The team needs a shared source of context that can evolve with the work.

Not a giant prompt containing every company document. Not identical instructions for every AI.

The right context, at the right scope, with a clear distinction between what is proposed, what is approved, and what is current.

The model can change. The tool can change.

The team’s memory should not have to start over.

This is why we are building onemind

onemind starts from a simple belief:

AI should not just work for a person. It should work as part of an organization.

We call the shared, versioned organizational memory a Mind: the goals, rules, skills, decisions, and knowledge that humans and AIs need to work from.

onemind connects that Mind with the people, AI members, projects, and tools that use it.

Our starting point is AI coding workflows, where the problem is concrete. Project context needs to be reviewed, versioned, and delivered to connected tools—not repeatedly reconstructed by every developer and every agent.

The goal is not to make everyone abandon their preferred tools.

It is to let them keep those tools without keeping the team’s knowledge trapped inside them.

An approved architecture decision should be available to the relevant coding agents. A revised standard should not depend on every teammate manually copying it. A handoff should preserve what matters about the work, not force the next contributor to rediscover it.

That is the shift we are building toward: from separate assistants serving individual employees to connected intelligence working as part of one team.

Buying AI access is a starting point.

But the goal is not simply to generate more work.

It is to make the whole team work better.

Many intelligences. One Mind.

AI is becoming dramatically more capable.

But an AI today is no longer just an LLM.

We start with a model, then give it a shell. We add system prompts, tools, skills, memory, files, workflows, harnesses, and ways to learn from previous work.

Put all of these together, and you get something bigger than intelligence alone.

We call it a Mind.

Intelligence is not a Mind

Think about a human.

Having intelligence means you have a functioning brain. But your brain alone does not define who you are.

Throughout your life, you learn.

You are trained.

You develop skills.

You accumulate memories and experiences.

You learn how to use tools.

You form habits, rules, preferences, goals, and ways of thinking.

Eventually, you develop answers to questions like:

Who am I?

Where do I come from?

What can I do?

What have I learned?

What do I believe?

Where do I want to go?

That is your Mind.

AI is starting to develop in the same direction.

An LLM provides intelligence.

But an AI that can actually work needs much more around that intelligence.

Its Mind might include:

• the model it uses,
• its system and internal prompts,
• the tools it can access,
• the skills it has learned,
• its memory,
• the files and knowledge it can read,
• the rules it must follow,
• the workflows it understands,
• the harness that shapes how it works,
• and the experience accumulated from previous tasks.

The model can be replaced.

Tools can change.

Skills can improve.

Memory can grow.

Experience can accumulate.

The Mind evolves.

We are already building Minds

Look at how modern AI products are evolving.

At first, we mostly talked directly to an LLM.

Then we gave it tools.

Then code execution.

Then memory.

Then MCP servers.

Then skills.

Then agents.

Then subagents.

Then increasingly sophisticated harnesses that determine how an AI plans, searches, calls tools, checks its work, learns, and collaborates with other agents.

We keep adding things around the model because raw intelligence is not enough to do real work.

A brilliant model with no context can still be a terrible teammate.

A slightly weaker model with the right tools, skills, memory, rules, and experience can sometimes perform much better.

The industry usually talks about these pieces separately:

Prompt engineering.

Context engineering.

Agent engineering.

Harness engineering.

Memory.

Skills.

Tools.

But from another perspective, they are all parts of the same thing:

we are constructing Minds around artificial intelligence.

But having a Mind is not enough

Now consider another question:

How do humans align their Minds?

We talk.

We debate.

We have meetings.

We write documents.

We teach each other.

We review each other's work.

We make decisions together.

And through all of these interactions, one person's understanding can become shared understanding.

Now ask the same question about AI:

How do AIs align their Minds?

Today, the answer is surprisingly primitive.

Someone commits an AGENTS.md file to Git.

Someone maintains shared Cursor rules.

Someone writes a document.

Someone posts a decision in Slack.

Someone manually tells their AI what happened in a meeting.

Someone remembers to update one tool but forgets another.

In other words, the human behind each AI is still responsible for keeping that AI's Mind aligned with the team.

And that breaks very quickly.

An AI may be incredibly intelligent.

It may know how to write code, analyze markets, design interfaces, or create strategies.

But it can still start work knowing almost nothing about the team it is supposed to work with.

It does not automatically know:

• what the team is building,
• why previous decisions were made,
• which standards must be followed,
• what has already been tried,
• which ideas were rejected,
• how the organization prefers to work,
• what another AI discovered yesterday,
• or what other humans and AIs have already learned.

Its intelligence may be excellent.

Its Mind may even be powerful.

But its Mind is not aligned with the team.

And every AI in the organization may be operating with a different Mind.

A shared Mind for humans and AI

Imagine a product team.

A designer works with an AI and develops a better interaction pattern.

That knowledge becomes part of the Project Mind.

A senior engineer establishes a new architecture boundary.

That becomes part of the Project Mind too.

The product manager changes the product strategy.

The Mind changes.

An AI discovers that a technical approach fails under a particular condition.

That experience can become part of the Mind.

Then another developer opens Codex.

The relevant design standards and architecture boundaries are already available.

Another teammate uses Cursor.

It receives the same project knowledge in the format Cursor understands.

Someone else uses Claude Code.

Claude receives the relevant part of the same Mind.

A new engineer joins six months later.

Their AI does not start from zero.

It already has access to what the team has learned.

This creates an important shift:

knowledge stops belonging to a person, an AI session, or a specific tool.

It becomes part of the organization.

And when the organization learns something, its humans and AIs can learn together.

A Mind is not a big prompt

This distinction matters.

You can put a huge amount of information into one prompt.

That does not make it a Mind.

A real Mind has structure.

It knows where knowledge comes from.

It changes over time.

It accumulates experience.

It has history.

It has permissions.

It understands scope.

It connects knowledge to actions.

And it can deliver the right context to the right intelligence at the right time.

For an organization, a Mind therefore needs to be:

Living.
It evolves as humans and AIs learn.

Versioned.
You can understand what changed, when it changed, and why.

Shared.
Humans and AIs can contribute to the same organizational understanding.

Scoped.
An organization, team, project, person, and AI can each have different layers of knowledge.

Permissioned.
Not every person or AI should know or change everything.

Composable.
A Project Mind can inherit from a Team Mind or Organization Mind while developing its own knowledge.

Portable.
Knowledge should survive when models and AI tools change.

Active.
It should not merely store information. It should participate in work.

Aligned.
When something important changes, the Minds that depend on it should be able to change with it.

From AI agents to AI organizations

The first generation of AI was mostly:

Human ↔ LLM

Then we moved toward:

Human ↔ Agent

Now we are entering something much bigger:

Many humans ↔ many AIs ↔ many tools

At that scale, giving every AI a better prompt is not enough.

Giving every AI individual memory is not enough.

Building better agents is not enough.

Even giving every AI its own powerful Mind is not enough.

Because the real challenge becomes:

How do all of these Minds work together?

The organization itself needs memory.

It needs skills.

It needs standards.

It needs experience.

It needs mechanisms for learning.

It needs mechanisms for alignment.

It needs to know what it knows—and make that knowledge available to the right intelligence when it matters.

In other words:

the organization needs a shared Mind.

This is what we are building at onemind.

Not another chatbot.

Not another AI coding interface.

Not another prompt manager.

onemind is a shared intelligence layer where the Minds of humans, AIs, projects, tools, skills, knowledge, decisions, and experience can connect, align, and evolve together.

Because AI-native organizations will not have one intelligence.

They will have many.

And the real advantage will not come from having the smartest individual AI.

It will come from whether all of those intelligences can learn together, stay aligned, and work as one organization.

Many intelligences. One Mind.