Accelerated Training

ACMF Training & Acceleration

Agents with access to historical project context reach autonomous operation materially faster than cold-start deployments. Connect your GitHub repository once and every agent in your deployment is accelerated 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

Every Agent Benefits Automatically

Knowledge is applied at the framework level — in the Research phase of every task and in the context each task is dispatched with. 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 credits toward reducing the task count agents need before they can progress. Sources are weighted by how much they reveal about operating your system; operational history counts the most.

Git Commit History

Active

Codebase patterns, file hotspots, change coupling, commit conventions, directory activity, and author patterns.

File hotspots: src/api/auth.go modified in 45% of commits

Change coupling: middleware.go + routes.go change together 78% of the time

Conventions: team uses feat:/fix:/chore: prefixes in 92% of commits

BUILDMAINTAINEVOLVE

PR Review History

Coming Soon

Code quality standards, review patterns, change request hotspots, and team review preferences.

Review patterns: security fixes get approved faster than feature changes

Change request hotspots: database migrations get 3x more change requests

Conventions: team requires 2 approvals for infrastructure changes

BUILDSECUREGOVERN

Incident History

Coming Soon

Operational patterns, incident frequency by component, resolution patterns, and MTTR metrics.

Incident frequency: payment service has 3x more incidents than auth service

Resolution patterns: 60% of database incidents resolved by connection pool tuning

Response time: MTTR for API incidents averages 23 minutes

OPERATEMAINTAINOPTIMIZE

Documentation Coverage

Coming Soon

Documentation presence, staleness, API docs, and architecture decision records.

Coverage: 12/20 services have README files, 5/20 have API docs

Staleness: infrastructure docs not updated in 6 months despite 200 code changes

ADRs: 3 architecture decision records found in docs/adr/

BUILDGOVERNEVOLVE

Credit System & Acceleration

Historical project data generates credits that reduce the minimum number of tasks an agent must complete before it can progress. Credits are capped so that agents still demonstrate competence through real task execution; history never substitutes for more than half of it.

How Credits Are Earned

Volume — more history (commits, reviews, incidents, documents) earns more credit.
Relevance — each source counts toward the capabilities it informs: commit history toward BUILD, incident history toward OPERATE.
Quality — consistent, well-formed history (conventional commit messages, linked reviews) earns more than noisy history.
Recency — recent history is worth more than old history.

Credits Only Reduce the Task Count

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 ID
max_commits — Maximum commits to process (default: 200, max: 500)
force — Set true to 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_hotspot

Files modified most frequently — helps agents prioritize review and testing

change_coupling

Files that change together — agents learn which files to co-modify

commit_convention

Team commit patterns — agents follow your conventions

directory_activity

Active directories — agents understand project structure

author_pattern

Contributor 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 — credits need 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.

Agents Notified

Every agent picks up the updated knowledge on its next task. No restart or reconfiguration is needed.

RIGOR Research Enrichment

The most significant knowledge items for your repository are added to every agent's Research phase automatically

Task Dispatch Enrichment

Project context travels with every task the orchestrator hands to an agent

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

Credits are proportional to the volume of history. Repositories with fewer than roughly 100 commits may not yet have enough history to earn a credit. 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

Every agent in your deployment receives project knowledge through two paths: the Research phase of each task, and the context attached to every task the orchestrator dispatches. No per-agent configuration is required.

BUILD

Requirements, planning, architecture, code, tests and review follow your conventions from the first task.

OPERATE

Deployment, monitoring, incident response and capacity planning start from your incident and change history.

SECURE

Scanning and threat hunting know which components have been fragile or exposed before.

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.

GitHub Integration Setup ACMF Maturity Model RIGOR Framework