Your Team's Engineering Knowledge —
Captured, Proven, and Injected
Into Every AI Session
MindMeld captures what your team knows — code patterns, architectural decisions, and business rules — validates them through real usage, and injects only what's relevant into every AI coding session via MCP. Standards that aren't followed get demoted. Knowledge that proves itself gets enforced.
For engineers: the AI already knows your team's patterns. For leaders: proof that knowledge compounds.
Standards aren't declared — they're earned.
Integrates via MCP (Model Context Protocol) with any compatible tool. Powered by 2,900+ enforced rules. Built by Equilateral AI.
The Problem: Knowledge Evaporates
Your team corrects AI output every day. Those corrections are institutional knowledge — and right now, they vanish.
Three types of knowledge. All at risk.
Code standards — "Never use connection pools in Lambda." Learned the hard way, forgotten next session.
Business decisions — "We chose OIDC over API keys for compliance." Lives in one person's head.
Architectural invariants — "Auth middleware rewrite is driven by legal, not tech debt." Lost when that engineer leaves.
MindMeld captures all three.
Static rules files capture what someone remembered to write down. MindMeld captures what your team actually does — code patterns, business decisions, and organizational knowledge — then proves what works and injects it automatically.
Not just code standards. The full picture of what your engineering organization knows.
From Corrections to Governance
MindMeld connects to your AI tools via MCP (Model Context Protocol) — the open standard for tool-to-model communication. No vendor lock-in. One integration, every tool.
The Correction-to-Standard Pipeline
Static Rules (Everyone Else)
Those corrections are wasted — nobody captures them.
MindMeld Pipeline
Every correction makes the system smarter. Permanently.
The Standards Maturity Lifecycle
Standards aren't declared — they're earned. Every correction moves a pattern through a lifecycle that no static rules file can replicate.
Provisional
Pattern detected from corrections. Soft suggestion injected.
0–2 sessions
"We noticed your team prefers X"
Solidified
Validated across multiple developers. Strong recommendation.
3–9 sessions, 85%+ adoption
"Team consensus: always do X"
Reinforced
Battle-tested invariant. Violations flagged automatically.
10+ sessions, 97%+ compliance
"This breaks team standard X"
Standards are measured, not mandated.
Maturity is earned through real usage data — not declared by someone writing a wiki page. Unused standards get demoted automatically.
Not Just Standards. Governance.
Static rules files are governance by suggestion. MindMeld is governance by architecture — standards injected before the first token is generated.
Governance leads AI, not the other way around. Standards are present during generation — not applied after the fact.
| Dimension | Static Rules | MindMeld |
|---|---|---|
| When governance happens | After generation (too late) | Before generation (by design) |
| Enforcement mechanism | Hope the AI reads the file | Injected into context at session start |
| What happens to stale rules | They stay forever | Auto-demoted based on usage data |
| Who maintains them | Someone who forgot months ago | The system, from team behavior |
| Audit trail | None | Author, timestamp, maturity, adoption |
| First output distance | Far — multiple correction cycles | Close — standards present during generation |
First Output Distance
The metric that matters: how far is the AI's initial generation from architecturally correct code?
With static rules, the first output is often far from correct. Multiple correction cycles required. Each iteration introduces drift.
With MindMeld, standards are present during generation. The first output is already close to correct. Iterations refine rather than repair.
You're not faster per iteration — you need fewer iterations.
Intelligent Injection: Only What Matters
Static rules files dump everything into every session. They can't learn, can't demote what's stale, and can't prove ROI. MindMeld injects only the standards relevant to what you're working on right now.
Static Rules (.cursorrules, CLAUDE.md)
- All rules injected every session
- Same rules for auth work and UI work
- Grows forever, nobody maintains it
- 550,000 tokens to load the full library
Intelligent Injection (MindMeld)
- Top 10 relevant rules per session
- Context-aware: knows what you're touching
- Auto-curates based on usage data
- 400 tokens. Under 2 seconds.
400 tokens vs. 550,000.
Full library token count calculated from concatenated OSS + commercial rule set. Reproducible: mindmeld-injection-demo.sh --all
Works Where Context Is Precious
Cloud models give you 200k tokens. Local models give you 8–64k. Either way, MindMeld's 400-token injection means your standards work everywhere — even on a laptop running Ollama.
Session-to-Commit Attribution
MindMeld doesn't just inject standards. It measures outcomes.
Every AI-assisted session is correlated to actual code commits — with three attribution windows:
Immediate
Direct session-to-commit correlation. Developer used AI assistance and committed code in the same work block.
Async
Developer took AI-assisted patterns and applied them later. Influence traceable but not immediate.
Delayed
Standards absorbed during AI sessions surface in commits days later. This is capability compounding — the developer internalized the pattern.
Most platforms count commits. MindMeld measures whether AI assistance is producing engineers who learn and compound — or engineers who copy and plateau.
What You'll See, When
Results compound over time. Here's what to expect.
Week 1
- Standards injected into every session
- First corrections captured automatically
- AI outputs align with your existing patterns
- Fewer "no, do it this way" moments
Month 1
- Provisional standards earning maturity
- Business decisions captured alongside code
- Team convergence metrics visible
- Stale standards auto-demoted
Quarter 1
- Reinforced standards across the team
- Session-to-commit attribution data
- Capability compounding measurable
- Institutional knowledge survives turnover
CFO-Ready From Day One
Four reporting tabs built for the executive conversation — not the developer dashboard.
Engineering Investment
What is the organization spending on AI-assisted development? Session volume, commit correlation, cost per governed session.
Standards ROI
Which standards produce the highest compliance? Which are being ignored? Adoption curves, maturity progression, demotion rates.
AI Leverage
Is AI assistance improving engineering capability or creating dependency? Capability progression vs. activity metrics.
Risk Forecast
Which engineers are at risk of capability plateau? Which standards are drifting? Early warning signals with evidence.
This is not a developer dashboard with an export button. This is a governance reporting layer designed for the CTO presenting to the board.
Governance Before the Incident
Not after.
AWS's own AI coding tool decided to "delete and recreate" a production environment. 13-hour outage. Amazon's response: mandatory peer review and staff training — after the incident.
That's governance by policy. It responds to drift. It doesn't prevent it.
MindMeld prevents architectural drift before it becomes production risk.
Standards are injected before the first token is generated. Violations are detected at session time, not deploy time. Maturity scoring demotes standards that stop being followed — surfacing divergence before it compounds into a codebase split.
When a new developer's AI sessions consistently violate standards that the rest of the team follows, that's a coaching signal — not a mystery that surfaces six months later in a production incident.
Authority must live outside the model.
The AI doesn't decide whether to follow your standards. The platform enforces them before the AI generates its first line of code.
Read more: Governance Is Not a Prompt →Capability, Not Activity
Developer productivity tools measure what developers do. MindMeld measures what developers become.
Quality Scores
Standards adherence per developer, per project, over time. Not lines of code.
Capability Progression
Is this engineer improving? Are patterns learned from AI showing up in their unassisted work?
Violation Trending
Not punitive. Diagnostic. A rising violation rate on a standard means the standard needs review, not the developer.
AI Coaching Recommendations
Evidence-based suggestions for which standards a specific developer should focus on. Based on actual gaps.
The Knowledge Transfer Problem
When seniors stop explaining things to juniors because the AI is faster, institutional knowledge stops accumulating. When that senior leaves, the knowledge leaves too.
MindMeld captures what they knew before they walk out the door.
Every correction has an author, a timestamp, and a maturity trail. That's auditable institutional memory.
Tested Across 6 Local Models
Same task. Same script. Same 400 tokens of injected rules. Every model scored on 6 Lambda best practices.
Every model improved. None got worse. Same 400 tokens, same script, six different model families.
| Model | Baseline | + MindMeld | Gain |
|---|---|---|---|
| devstral (24B) | 1/6 | 6/6 | +5 |
| deepseek-coder-v2 (16B) | 1/6 | 5/6 | +4 |
| qwen2.5-coder (14B) | 2/6 | 5/6 | +3 |
| qwen3-coder (30B) | 2/6 | 5/6 | +3 |
| codegemma (7B) | 2/6 | 5/6 | +3 |
| codellama (13B) | 1/6 | 3/6 | +2 |
models improved
avg gain from 400 tokens
more efficient than full dump
models got worse
Task: Write a Lambda + PostgreSQL handler. Scored on 6 best practices.
Reproducible: mindmeld-injection-demo.sh --all
See It In Action
This is what happens when you start a coding session with MindMeld installed.
MindMeld picks the 10 rules that matter for THIS session and ignores the rest. If a standard never gets used, it gets demoted automatically.
Free tier: 68 standards / 808 rules. Pro tiers add intelligent injection + your own standards. Enterprise: 240+ standards / 2,900+ rules.
<2s
Relevance scoring + injection
240+
Standards · 2,900+ Rules
10
Relevant standards per session
7+
AI tools supported via MCP
Three Approaches. One Winner.
| Static Rules | Vector DB / RAG | MindMeld | |
|---|---|---|---|
| Context awareness | ✕ None | △ Retrieves, doesn't curate | ✓ Scored per session |
| Maturity lifecycle | ✕ None | ✕ None | ✓ Provisional → Reinforced |
| Learns from corrections | ✕ Never | ✕ Never | ✓ Automatically |
| Business decisions & invariants | ✕ Code only | ✕ Code only | ✓ Code + business + architectural |
| Team convergence | ✕ Files drift apart | ✕ No measurement | ✓ Measured and reported |
| Executive reporting | ✕ None | ✕ None | ✓ Four-tab CFO-ready suite |
| Session-to-commit attribution | ✕ None | ✕ None | ✓ Three attribution windows |
| Audit trail | ✕ None | ✕ None | ✓ Author, timestamp, maturity |
Open Source Foundation
MindMeld's commercial platform is built on an open-source governance stack maintained by Equilateral AI. Start free, scale when you need intelligent injection and team analytics.
⛽ Open Standards
17 YAML standards, 147 rules across 4 categories. MIT licensed. Fork and customize.
📚 project-object
The injector. Scans your project and injects relevant standards into AI context. Free forever.
⚙ Open Core
19 specialized agents, hooks, and governance infrastructure. Claude Code compatible.
👥 Community Standards
51 YAML patterns, 661 rules. Battle-tested patterns contributed by the community.
Combined OSS: 68 standards / 808 rules.
Open source gives you static injection. MindMeld adds what static files can't: maturity tracking, auto-demotion, business invariants, team convergence, and proof that it's working.
Agent Governance Scorecard
Evaluate any platform — including ours. Six dimensions. Twenty criteria. Evidence-based.
Control Towers
Central authority over agent operations
Decision Integrity
Reasoning preserved and traceable
Observability
Every action logged and auditable
Governance Enforcement
Runtime controls, not just policy
Human-in-the-Loop
Calibrated trust with intervention points
Drift Detection
Behavioral change detected and attributed
Roadmaps don't count.
View the Scorecard →Start Free. Contribute to Save. Scale With Governance.
Code FOUNDER80 auto-applied at checkout. Limited availability.
Contributing your standards back makes the ecosystem stronger. Every contribution gets battle-tested by other teams and earns attribution for your engineers.
Open Source
Standards injection, no account required
- project-object session memory
- 1 participant, 3 projects
- Create your own standards
- Cross-platform sync
Pro Solo
Intelligent injection + standards that learn
Founding member rate — first 12 months
- Context-aware injection (top 10 per session)
- Standards maturity lifecycle
- 5 participants, 5 projects
- Create your own standards
- Cross-platform sync
Pro Team
Team governance + analytics
Founding member rate — first 12 months
- Standards picker (per-user control)
- Team convergence analytics
- Developer capability tracking
- 10 participants, unlimited projects
- All Pro Solo features
Why the $50 difference? Contributing your standards back makes the ecosystem stronger. If your organization can't share — that's fine. Private tiers give the same capabilities.
Contributing saves $50/mo. Keeping private costs $50/mo. Same platform either way.
Enterprise — $179/seat/mo
25-seat minimum. This isn't a bigger Pro plan. This is governance instrumentation.
Control Tower
- Session-to-commit causal attribution (3 windows)
- Developer capability progression tracking
- Central visibility across all AI-assisted development
Audit Fabric
- Four-tab executive reporting suite
- Full library: 240+ standards / 2,900+ rules
- SSO, onboarding acceleration, dedicated support
Founding member pricing: 80% off for 12 months. After Year 1, prices return to standard rates.
From the Equilateral Blog
Governance Is Not a Prompt. It's an Authority System.
AWS's own AI coding tool decided to "delete and recreate" a production environment. 13-hour outage. Here's why governance must be architectural.
Read →From Vibe to Glide: Why AI Agents Need Governance Before Generation
Cursor's research showed agents spiral in endless correction loops. We built an open-source solution.
Read →The Agent Layer Executes. MindMeld Remembers. Equilateral Enforces.
Open-source agents solved execution efficiency. MindMeld solves what they forgot: institutional memory that compounds across every tool in your stack.
Read →Get started in minutes
Replace your static rules file with knowledge that learns, proves itself, and gets injected automatically.
Setup guides for your tool: