ACMF Training & Acceleration
Agents with access to historical project context achieve autonomous operation 40-50% faster than cold-start deployments. Connect your GitHub repository to accelerate all 29 agents through the ACMF maturity levels.
How Knowledge Accelerates Training
1. Connect GitHub
Install the GitHub App on your repository
2. Ingest History
Autonoma analyzes commits, PRs, incidents, and docs
3. Knowledge Extracted
Patterns, conventions, and context become agent knowledge
4. Credits Granted
ACMF thresholds reduced — agents progress faster
All 29 Agents Benefit Automatically
Knowledge is injected at the framework level — into the RIGOR Research phase and the orchestrator's task dispatch. Every agent receives project context without any per-agent configuration. Connect your repo once, and all agents learn your codebase.
Four Knowledge Sources
Each source contributes weighted credits toward reducing ACMF progression thresholds. Incident history carries the highest weight because operational patterns are the most valuable for autonomous operation.
Git Commit History
Codebase patterns, file hotspots, change coupling, commit conventions, directory activity, and author patterns.
PR Review History
Code quality standards, review patterns, change request hotspots, and team review preferences.
Incident History
Operational patterns, incident frequency by component, resolution patterns, and MTTR metrics.
Documentation Coverage
Documentation presence, staleness, API docs, and architecture decision records.
Credit System & Acceleration
Historical project data generates credits that reduce the minimum task thresholds required for ACMF progression. Credits are capped at 50% reduction to ensure agents still demonstrate competence through real task execution.
Credit Calculation
credits = (recordCount / 100) × sourceWeight × capabilityRelevance × qualityMultiplier × dateBonus
Where:
recordCount = number of records (commits, PRs, incidents, etc.)
sourceWeight = data source weight (0.10 - 0.25)
capabilityRelevance = how relevant the source is to each capability (0.0 - 1.0)
qualityMultiplier = data quality score (0.0 - 1.0)
dateBonus = recency bonus (more recent data = higher bonus)
Example: 1000 commits × 0.20 weight × 0.8 BUILD relevance × 0.9 quality × 1.2 date
= 1000/100 × 0.20 × 0.8 × 0.9 × 1.2 = 1.73 → 1 credit for BUILD
effectiveMinTasks = max(minTasks × 0.50, minTasks - totalCredits)
= minimum 50% of original threshold| Transition | Default MinTasks | With Full Credits | Speedup |
|---|---|---|---|
OBSERVE → LEARNING | 100 | ~50 | 50% |
LEARNING → ASSISTED | 200 | ~100 | 50% |
ASSISTED → AUTONOMOUS | 500 | ~250 | 50% |
Credits Only Reduce MinTasks
Success rate, consecutive success, max override rate, and min confidence thresholds are never reduced. Agents must still prove competence — credits only reduce how many tasks are needed to demonstrate it.
Setup Guide
Follow these steps to connect your repository, ingest your project history, and start accelerating agent training. This is the exact pipeline used in production.
Prerequisites
- Autonoma GitHub App installed on your repository (GitHub Integration Guide)
- Required GitHub App permissions:
Contents: Read,Pull requests: Read,Issues: Read - Push webhook enabled (installed by default with the GitHub App)
- Your Autonoma API token and customer ID (available in your Alpha Dashboard)
Trigger Initial Commit History Ingestion
After installing the GitHub App, trigger a full ingestion of your existing commit history. This processes up to 500 commits and extracts codebase patterns, file hotspots, change coupling, and conventions.
curl -X POST \
https://www.theautonoma.io/api/v1/workflows/knowledge/ingest \
-H "Authorization: Bearer YOUR_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"repo": "your-org/your-repo",
"customer_id": "cust_abc123",
"max_commits": 500,
"force": true
}'Response
{
"status": "completed",
"repo": "your-org/your-repo",
"commits_processed": 487,
"knowledge_items_created": 2530,
"credits_granted": {
"BUILD": 1,
"EVOLVE": 1
},
"duration_ms": 12450
}Parameters:
repo— Full repository name (org/repo format)customer_id— Your Autonoma customer IDmax_commits— Maximum commits to process (default: 200, max: 500)force— Settrueto re-ingest from scratch, ignoring the watermark (use for initial setup or re-ingestion)
Verify Ingestion Status
Confirm that ingestion completed and check the watermark — the SHA of the last processed commit. Future push events will only process commits after this watermark.
curl -H "Authorization: Bearer YOUR_API_TOKEN" \ "https://www.theautonoma.io/api/v1/workflows/knowledge/status?repo=your-org/your-repo"
Response
{
"repo": "your-org/your-repo",
"total_commits_ingested": 487,
"knowledge_items": 2530,
"last_ingested_at": "2026-01-31T04:18:58Z",
"last_ingested_sha": "6edacd828af7c1b3e9...",
"watermark_sha": "6edacd828af7c1b3e9..."
}Watermark: The watermark_sha tracks the last processed commit. Incremental ingestion (from push webhooks) only processes commits after this SHA. Use "force": true in Step 1 to reset the watermark and re-ingest from scratch.
Query Extracted Knowledge
Browse the knowledge items extracted from your repository. These are the patterns that agents receive in every task's RIGOR Research phase.
curl -H "Authorization: Bearer YOUR_API_TOKEN" \ "https://www.theautonoma.io/api/v1/workflows/knowledge/query?repo=your-org/your-repo&limit=10"
Response (example items)
{
"repo": "your-org/your-repo",
"total_items": 2530,
"items": [
{
"type": "file_hotspot",
"key": "src/api/auth.go",
"summary": "Modified in 45% of commits (218/487). Primary hotspot.",
"confidence": 0.92
},
{
"type": "change_coupling",
"key": "src/middleware.go+src/routes.go",
"summary": "Changed together in 78% of mutual commits. Strong coupling.",
"confidence": 0.85
},
{
"type": "commit_convention",
"key": "conventional_commits",
"summary": "Team uses feat:/fix:/chore: prefixes in 92% of commits.",
"confidence": 0.94
},
{
"type": "directory_activity",
"key": "src/api/",
"summary": "Most active directory with 340 file changes across 487 commits.",
"confidence": 0.88
},
{
"type": "author_pattern",
"key": "alice",
"summary": "Primary contributor (42% of commits). Focuses on src/api/ and src/auth/.",
"confidence": 0.80
}
]
}Knowledge Types Extracted:
file_hotspotFiles modified most frequently — helps agents prioritize review and testing
change_couplingFiles that change together — agents learn which files to co-modify
commit_conventionTeam commit patterns — agents follow your conventions
directory_activityActive directories — agents understand project structure
author_patternContributor patterns — agents understand team structure
Verify ACMF Credits Were Granted
Credits are granted automatically during ingestion. Check the ingestion response (Step 1) for thecredits_granted field. Credits reduce the minimum task count required for each ACMF level transition.
Credit Scaling by Repository Size
| Repo Size | Commits | Expected Credits | MinTasks Impact |
|---|---|---|---|
| Small | 50-100 | 0-1 per capability | Minimal impact |
| Medium | 200-500 | 1-3 per capability | Moderate reduction |
| Large | 500+ | 3-10+ per capability | Significant reduction |
Small repos: Repositories with fewer than ~100 commits may receive 0 credits initially. This is expected — the credit formula requires sufficient data volume. Credits accumulate as more commits are pushed. With all four data sources (commits + PR reviews + incidents + docs), even small repos reach meaningful credit levels.
Automatic Pipeline (After Initial Setup)
Once the initial ingestion is complete, the pipeline runs automatically. Every git push triggers the full cycle with no manual intervention required.
Push Event Received
GitHub webhook delivers push event to Autonoma. Contains commit SHAs and repository info.
Incremental Ingestion
Only new commits (after the watermark SHA) are processed. Existing knowledge is preserved and updated.
Knowledge Updated & Credits Granted
New patterns are extracted, knowledge items are updated, and ACMF credits are recalculated.
NATS Event Published
A project.knowledge.updated event is published with {repo, source, commits_processed, knowledge_items}. All agents receive the updated knowledge on their next task.
RIGOR Research Enrichment
Top 30 knowledge items (by occurrence count) injected into every agent's Research phase automatically at the framework level
Task Dispatch Enrichment
Top 20 knowledge items included in every orchestrator task payload via NATS dispatch
Verification & Troubleshooting
Verification Checklist
After completing the setup, verify each component of the pipeline is working:
Ingestion returns commits_processed > 0
If 0 commits processed, check that the GitHub App has Contents: Read permission and the repo name is correct.
Knowledge query returns items with types like file_hotspot, change_coupling
If no items returned, ingestion may still be processing. Wait and re-query.
Status endpoint shows watermark_sha matching your latest processed commit
This SHA is the boundary — only commits after it will be incrementally processed on future pushes.
Credits appear in ingestion response (for repos with 200+ commits)
Credits may be 0 for small repos — this is normal. Credits accumulate with more commits and additional data sources.
Common Issues
Re-ingestion returns 0 commits
The watermark prevents re-processing commits that have already been ingested. To re-ingest from scratch, set "force": true in the ingestion request. This resets the watermark and processes all commits again.
Credits granted: 0 for all capabilities
The credit formula divides record count by 100 and multiplies by several factors. Repos with fewer than ~100 commits may not generate enough raw value to yield credits (values below 1.0 round down to 0). This is expected — credits increase as you push more commits and when PR review and incident ingestion become available.
Push webhook not triggering incremental ingestion
Verify the GitHub App is installed with push event webhook enabled. Check your GitHub App settings under Settings → Developer settings → GitHub Apps → Permissions & events. The push event must be subscribed.
Knowledge items seem stale after new pushes
Incremental ingestion only processes commits after the watermark. If patterns shift significantly (e.g., major refactor), trigger a full re-ingestion with "force": true to recalculate all patterns from scratch.
Agent Coverage
All 29 agents receive project knowledge through two injection paths: the RIGOR Research phase (framework-level) and the orchestrator task dispatch (NATS payload). No per-agent configuration is required.
Best Practices for Faster Training
Do
- Use consistent commit message conventions (feat:, fix:, chore:, etc.)
- Ingest maximum commit history on first setup (500+ commits ideal)
- Enable push webhooks for continuous incremental ingestion
- Maintain documentation alongside code for higher doc coverage scores
- Use PR reviews to build review pattern knowledge (when available)
Avoid
- Expecting immediate AUTONOMOUS mode — credits reduce thresholds, not bypass them
- Very small repos (<50 commits) — insufficient data for meaningful patterns
- Inconsistent commit messages — reduces the quality score used in credit calculation
- Disabling GitHub webhooks — agents miss incremental updates
Continue Exploring
Set up your GitHub integration to start training, or learn more about ACMF and RIGOR.