^ AI Organization Knowledge & Rules Standardization

Careti is designed so that AI accurately understands and follows your team's coding rules and standards. Through this system, AI functions as a true team member that understands project context, not just a simple code generation tool.

Why Is Knowledge Synchronization Important?

Situation	Generic AI Tools	Careti
Team Rule Compliance	Doesn't know rules	✅ Automatically recognizes rule files
Project Context	Needs explanation every time	✅ Persistent memory
Code Consistency	Different styles per tool	✅ Maintains team standards
Role Optimization	None	✅ Separate AI/Human documents

Core Concept 1: Dual Directory Architecture

Careti acknowledges that documents for AI and humans serve different purposes. To address this, it uses two directories:

your-project/
├── .agents/                    # For AI (English, token-optimized)
│   ├── context/               # System rules
│   │   ├── agents-rules.json  # Main rules file (SoT)
│   │   └── ai-work-index.yaml # Work index
│   ├── workflows/             # Task workflows
│   │   └── atoms/             # Reusable building blocks
│   ├── skills/                # AI skills
│   └── hooks/                 # Event hooks
│
├── .users/                     # For humans (native language, detailed)
│   ├── context/               # Project context (Markdown)
│   ├── workflows/             # Workflow guides
│   └── skills/                # Skill guides
│
└── AGENTS.md                   # AI entry point

Why Separate?

Category	.agents/ (For AI)	.users/ (For Humans)
Language	English (token efficient)	Native language
Format	JSON/YAML (structured)	Markdown (readable)
Purpose	Ensure deterministic behavior	Provide detailed explanations
Target	AI agents	Developers/Team members

Token Optimization: Files in .agents/ are written in English to convey the same meaning with fewer tokens. This efficiently uses the context window and reduces costs.

Core Concept 2: Atomic Knowledge System

Careti uses an Atomic Knowledge approach. Instead of a single massive document, knowledge is broken into minimal units (Atoms) and combined as needed.

How It Works

1. Task Analysis: AI reads ai-work-index.yaml to identify the task type
2. Workflow Loading: Only reads the relevant workflow file
3. Knowledge Atom Composition: Loads only the atoms referenced by the workflow
4. Task Execution: Performs the task with combined knowledge

Example

.agents/workflows/
├── code-review.md             # Code review workflow
├── feature-implementation.md  # Feature implementation workflow
└── atoms/                     # Reusable building blocks
    ├── tdd-cycle.md           # TDD cycle
    ├── naming-conventions.md  # Naming conventions
    └── document-changes.md    # Documenting changes

Benefit: Instead of always loading all rules, AI selectively loads only the rules needed for the current task, saving tokens.

Core Concept 3: Rule Location & Priority

Careti uses the .agents/context/ folder as the single source of rules. This ensures AI follows consistent standards across the entire project.

Rule Locations

Type	Location	Purpose
Workspace Rules	.agents/context/	Project-specific rules
Directory Scope	AGENTS.md	Apply to specific folders only
Global Rules	Documents/Careti/Rules	Apply to all projects
Workflows	.agents/workflows/	On-demand loading

Why Is Standardization Important?

Problem	Solution
Rules scattered in multiple places	Manage in one place
Rule conflicts occur	Clear priority order
AI misses rules	Guaranteed automatic loading

Core Concept 4: Cross-Organization Knowledge Sync

Using submodules, you can share rules and knowledge across multiple projects throughout your organization.

Organization Repository Pattern

org-context/                      # Organization shared repository (Git)
├── .agents/                      # AI context
│   ├── context/                  # Organization rules/policies
│   │   ├── conventions.md        # Development conventions
│   │   ├── tech-stack.md         # Tech stack
│   │   └── security-policy.md    # Security policy
│   └── workflows/                # Workflow definitions
│       ├── code-review.md
│       └── release-process.md
│
├── .users/                       # User documentation (mirrored)
│   ├── context/
│   │   ├── dev-standards.md      # Detailed guide
│   │   └── tech-stack.md
│   └── workflows/
│       └── code-review-guide.md
│
└── AGENTS.md                     # Organization AI entry point

Connecting as Submodule

# Add organization context as submodule
git submodule add git@github.com:your-org/org-context.git

your-project/
├── .agents/                # Project rules
├── .users/                 # Project user documentation
├── org-context/            # ← Submodule (organization rules)
│   ├── .agents/
│   └── .users/
└── AGENTS.md

4-Layer Rule Merging

Layer 1: Global (User-wide)
    ~/.agents/                    # Personal AI rules

Layer 2: Organization
    org-context/.agents/          # Organization AI context

Layer 3: Project
    {project}/.agents/            # Project AI rules

Layer 4: Local (Per-directory)
    {project}/packages/{pkg}/
    └── AGENTS.md                 # Per-directory override

Merge Priority: Local > Project > Organization > Global

Use Cases

# All tasks possible in one project:

# Coding task
"Refactor this function"
→ References .agents/context/ rules for the task

# Company policy question
"What's the remote work policy?"
→ Reads org-context/.users/policies/remote-work.md and answers

# Workflow guide
"How do I do code review?"
→ References org-context/.users/workflows/code-review-guide.md

Quick Start: /init Command

If your project doesn't have the standard structure, you can auto-generate it with the /init command.

# In Careti chat
/init

This command:

• Creates .agents/ and .users/ folder structure
• Provides default rule templates
• Never overwrites existing files (safe)

Migrating Existing Projects

If you have rule files in other locations, move them to .agents/context/.

your-project/
├── .agents/
│   ├── context/          # Rule files
│   │   └── coding.md     # e.g., Coding standards
│   └── workflows/        # Workflows (optional)
└── AGENTS.md             # Root instructions (optional)

Key Benefits

1. True Partnership

AI and developers communicate based on the same documents, eliminating misunderstandings.

2. Token Efficiency

• Save tokens with English-written .agents/ files
• On-Demand Loading loads only necessary rules

3. Organization-Wide Consistency

All projects share the same organization rules through submodules.

4. Transparency

Developers can clearly see how AI works through the .agents/ folder.

5. Team Consistency

• All team members use the same rules
• AI reliability - never misses rules
• Version control - track rule change history
• Flexible scope - choose project/folder/global

Full Comparison with Cline

Item	Cline	Careti
Knowledge Sharing	Single file (plain text)	Atomic Knowledge System
Efficiency	Always loads all rules	On-Demand Loading
Role Separation	None	AI/Human separation
Bootstrap	Manual setup	/init auto-scaffold
Organization Sharing	None	Submodule pattern support
Rule Priority	Unclear	Clear 4-layer merging

Getting Started

Method 1: Auto Initialization (Recommended)

# In Careti chat
/init

Method 2: Manual Setup

1. Create .agents/context/ folder in project root
2. Write rules in Markdown files
3. Start chatting with Careti

For detailed rule writing guidelines, see the Careti Rules Feature documentation.

Related Documentation

• Careti Rules Feature - Rule writing guide
• Document Reading Tools - AI directly reads documents
• Image Tools - AI image generation/analysis