CI/CD for agent intelligence

Ship everything your agents learn.

Agentevo turns runs into candidate skills, regression tests and guards. Review evidence and promote explicitly, with raw captures kept local by default.

  • Localby default
  • 0raw-trace cloud endpoints
  • 0.11mslocal guard p95 · lab

Free 10,000 cloud requests/moNo card Offline capture + guard

Local agent runs become candidates. Explicit verification and promotion gates govern their supported reuse; verification tests are not sandboxed.

Start here · no account required

One command.
Start in your project.

Open a terminal in your project and paste this command. It fetches the CLI and initializes your local memory. No account or API key needed.

Requires Node 18+ and Python 3.10+. Prefer Python only? Or let your coding agent handle setup.

initialize local memory
npx @agentevo-cli/agentevo@0.2.9 init

Next: connect your coding agent. The ready-to-paste setup request walks your agent through the connection and asks you to approve its changes.

An empty memory is expected. Finish a small tested task before learning your first lesson. Nothing is uploaded by initialization.

One lifecycle. Built to travel across your agent stack.

  • Claude CodeLive
  • CodexBeta
  • CursorBeta
  • OpenCodeBeta
  • CI / QANext

01 Product truth

Memory is not a release process.

Remembering a run and trusting it are different jobs. Agentevo connects captured memory to evidence, explicit promotion rules and an external policy boundary.

Unverified

Memory without verification

  • 01

    Instructions are recalledSource, freshness, and authority are ambiguous.

  • 02

    Failures repeatBad paths stay as context instead of becoming tests.

  • 03

    Execution stays implicitThe model decides what to reuse and what to run.

  • 04

    Revocation is deletionNo preserved tombstone or provenance chain.

Governed

Agentevo intelligence lifecycle

  • 01

    Evidence before authorityExit codes, replay, controls, signatures, provenance.

  • 02

    Failures become guardsFingerprints branch into regression tests and prevention.

  • 03

    Policy stays outside the modelRecall returns data; the guard authorizes action.

  • 04

    Exit states preserve historyQuarantine and stale allow review; reject and revoke are terminal.

CaptureScrubCompileVerifyPromoteRecallGuard

02 System architecture

How verified intelligence is made.

Four visible decisions turn a raw agent run into reusable intelligence. Nothing is promoted in the dark.

  1. 01
    Observe

    Seal the local run as a clean, reviewable trace.

  2. 02
    Compile

    Keep the useful lesson. Remove noise and secrets.

  3. 03
    Verify

    Attach evidence, tests, and the limits that matter.

  4. 04
    Reuse

    Return one scoped skill when the next task needs it.

A run becomes a candidate capability.Verification and policy decide how it may be used. Every transition is visible; raw session data stays local.

The lifecycle

Now follow one lesson through every layer.

Illustrative

  1. 01Capture

    Your agent works as usual. The session lands in your encrypted local vault.

    agentevo capture --latest
  2. 02Scrub

    DLP swaps the secret for a marker before anything is persisted.

    runs inside capture
  3. 03Compile

    Events become typed candidate skills, tests, guards, and evidence links.

    agentevo compile --latest
  4. 04Verify

    Integrity, reported outcomes and current replay are shown separately; task correctness needs review.

    agentevo verify --latest --local --workdir .
  5. 05Promote

    Evidence plus policy promotes the object. A signature proves who made it—not that it is safe.

    agentevo promote --latest --to Verified --local
  6. 06Recall

    A later session receives matching Verified objects, ranked and capability-scoped.

    agentevo recall "fix flaky test" --capabilities Bash,Edit,Read
  7. 07Guard

    The proposed action crosses an external policy boundary before execution.

    agentevo guard @edit.json --tool Edit

03 Learning loop

Green runs become skills. Red runs become protection.

Agentevo does not erase the dead end. It fingerprints the failure, compiles a regression test, and gives the external guard something concrete to stop next time.

01Session4 tests pass 02Skilltyped candidate 03Verificationevidence bound 04PromotionL2 Verified 05Recallranked + scoped
Verifiedskill@v1

“Fix the flaky ISO-week test”

Evidence 4 · signed · Bash, Edit, Read
01Sessionassertion fails 02Fingerprinterror + action 03Regressionfuture check 04Guardpolicy object 05Preventionapproval required
Preventedguard@v1

“Block the edit that recreated the ISO-week failure”

Fingerprint matched · decision outside the model

Illustrative flow The object types and verdicts mirror the shipped local runtime; the scenario is an example, not a benchmark.

04 Trust ladder

Nothing is trusted on one run.

Objects climb only on verification evidence plus a policy decision. A signature proves who made something, never that it is safe to reuse.

Exits from any rung

  • Quarantined
  • Stale
  • Rejected
  • Revoked

None of them auto-execute. Revocation writes a tombstone, never a delete.

The Agentevo mark is the trust ladder: the left flank climbs from Observed to Candidate, Verified and Trusted; the straight right leg is the Compiled path, where work executes, back to the ground.

L0Observed

Raw or derived experience exists locally. Nothing is claimed about reusability yet.

Gate
Eligible source, classification, provenance hash.
Authority
None.

05 Recall + guard

Recall finds the lesson. The guard decides what may run.

Choose a task, inspect the ranked objects, then propose an action. The result is a policy verdict—not an instruction smuggled back into the model.

01 Choose a task
03 Propose an action

02 Ranked recall Illustrative

  1. 1skill@v11.00Verified
  2. 2regression_test@v10.82Verified
  3. 3guard@v10.76Verified

Recall outputExternal policy layer

04 Guard verdict

Allow

The action matches a Verified regression test, stays inside the requested Bash capability, and has a safe fallback.

Matched object
regression_test@v1
Decision source
Local policy runtime
Model authority
None

AllowDenyRequire approvalModify / constrainUnknown / stop

06 Developer quickstart

From transcript to skill.

Initialize your project, capture a tested run, inspect evidence and explicitly promote useful advice. Local memory needs no account or upload. Supported host setup and strict CI are explicit integration steps; guards govern supported proposed effects. Pick a step for its commands.

Auto-discovery The newest Claude Code session for the current repository.

agentevo capture --latest

Exported sessions Beta reads Agentevo's Codex JSONL interchange format—not native Codex session files yet.

agentevo capture session.jsonl --adapter codex

Exported sessions Beta reads Agentevo's Cursor JSONL interchange format—never Cursor's proprietary session store.

agentevo capture session.jsonl --adapter cursor

Exported sessions Beta reads Agentevo's OpenCode JSONL interchange format—the same contract as Cursor, stamped with the OpenCode agent id.

agentevo capture session.jsonl --adapter opencode

Example run2 Claude Code sessions · local

8 passed1 failed, now guardedIllustrative output

Step 1Capture

Adapters map provider events (prompts, tool calls, diffs, test results, human corrections) into one canonical contract with immutable ids and content hashes. Everything lands in your encrypted local vault.

--latest picks the newest Claude Code session for the directory you are in. Codex (beta) reads only sessions exported to Agentevo's Codex JSONL format: pass the file with --adapter codex.

  • Raw prompts, diffs and logs stay in your encrypted local vault
  • Capture keeps working fully offline
capture
# prefix every line with npx @agentevo-cli/agentevo@0.2.9, or install once:uv tool install agentevo-sdk==0.2.9agentevo skills installagentevo initagentevo doctor# newest Claude Code session for the current directoryagentevo capture --latestadapter claude-code · 2 sessions · 23 eventsstored in the local vault · nothing sent

Step 2DLP

Detected secrets are replaced with redaction markers before persistence. Tokens, keys, cookies and auth headers are never valid payloads; detection is bounded, so review sensitive material before sync.

dlp · inside capture
# runs inside capture: no command of its own- Authorization: Bearer eyJhbGciOi••••••••+ Authorization: Bearer ⟦REDACTED:jwt⟧1 secret redacted before persistence

Step 3Classify

Outcomes are classified deterministically first: success, failure, partial, cancelled or unknown. The first session went red, then green. The second ended red, so it forks.

The compiler turns each run into Candidates: typed, with their evidence links, and advisory only.

compile
agentevo compile --latestsession 1  pytest -q  1 failed → 4 passed  successsession 2  pytest -q  1 failed            failure → fork# state: Observed → Candidate, advisory only

Gate 1Verify

Review integrity and reported historical outcomes separately from fresh current replay. Verification runs supported declared tests in the explicit working copy; it does not prove task correctness or the original runner. Inspect JSON: interactive exit zero can include failed or inconclusive checks. A reviewed pinned CI manifest provides the strict nonzero gate.

verify
agentevo verify --latest --local --workdir .Illustrative output · inspect actual evidence dimensionsverdict: passcurrent replay: declared pytest command exited 0

Gate 2Promote

The second gate is explicit policy review. Verified is advisory; passing integrity alone does not establish fresh replay or task correctness. Trusted needs independent fresh evidence and approval where required.

  • High-risk promotion requires audited human approval
  • One successful run is never enough for Trusted
promote
agentevo promote --latest --to Verified --local# refused unless that evidence supports itstate: Candidate → VerifiedTrusted: 1 of 3 independent runs

Step 4Recall + guard

Local recall returns matching Verified and Trusted objects as data; Verified suggestions remain advisory. With supported host integration configured, guards check supported proposed actions outside the model; CLI installation alone does not intercept every action.

  • Allow, deny, or require approval, decided outside the LLM
  • Stale skills stop instead of running blind
recall and guard
agentevo recall "fix flaky test" --capabilities Bash,Edit,Read# use words from your session's task; --min-relevance 0 lists allskill@v1 · Verified# the typed action your agent proposes (arguments optional)cat > action.json <<'EOF'{"action_type": "exec", "target": {"kind": "path", "ref": "."}, "arguments": {"command": "pytest -q"}, "risk_class": "medium", "permissions": ["Bash"], "idempotency": "safe", "fallback": "stop"}EOFagentevo guard @action.json --tool BashALLOW  # or DENY, REQUIRE_APPROVAL, MODIFY/CONSTRAIN, UNKNOWN

ForkFailed run

A session that ends red is not thrown away. It is captured like any other, and the failure is fingerprinted, so the same mistake can be recognised the next time a step looks like it.

session 2 · captured like any session
session 2  pytest -q1 failed · test_parse_iso_weekfailure_signature: Bash:AssertionError:test_parse_iso_week

BranchRegression test

The failure becomes a test that later runs have to pass. It is verified and promoted through the same two gates as any skill.

regression test · compiled from session 2
regression_test@v1asserts: pytest -q exits 0state: Verified

BranchGuard

With the supported integration configured, a Verified guard evaluates a matching proposed step: allow, deny, require approval or constrain, decided outside the LLM.

guard · the failed edit, proposed again
cat > edit.json <<'EOF'{"action_type": "edit", "target": {"kind": "path", "ref": "/home/you/web/src/dates.py"}, "arguments": {"file_path": "/home/you/web/src/dates.py",  "old_string": "d.isocalendar().week",  "new_string": "int(d.strftime('%W'))"}, "risk_class": "medium", "permissions": ["Edit"], "idempotency": "safe", "fallback": "stop"}EOFagentevo guard @edit.json --tool EditREQUIRE_APPROVAL  # matched guard@v1 from the failed run

Artifacts

  • skill@v1CandidateVerified

    Fix the flaky ISO-week test

    sha256signed

  • regression_test@v1CandidateVerified

    pytest -q must exit 0

    sha256signed

  • guard@v1CandidateVerified

    Ask before the failed edit runs again

    sha256signed

Trusted needs three independent passing runs by default. This was run one.

07 Artifact registry

The lesson leaves as an object you can inspect.

Skills, tests, guards, evidence, provenance, verification, and tombstones share one typed contract. The browser below is illustrative; its fields mirror the shipped schemas.

Artifact DNA · illustrative relationship map

Proof travels with the object.

Provenance and evidence feed verification. Verification can promote a reusable skill or preserve a failed path as a test and guard. Revocation stays visible as a tombstone.

Inspectingskill@v1

Verifiedskill@v1

Illustrative object

Fix the flaky ISO-week test

A minimal reusable procedure whose passing test command travels with it.

State / trust
Verified · L2
Version
1
Signature
sha256:7f…91
Evidence
4 receipts
Source
Claude Code session
Timestamp
Example · 2026-10-02T09:32Z
Capabilities
Bash · Edit · Read
Revocation
Active

Verifiedregression_test@v1

Illustrative object

ISO-week behavior must stay stable

The failed path is converted into an executable check for later runs.

State / trust
Verified · L2
Version
1
Signature
sha256:b2…0c
Evidence
3 receipts
Source
Failure fingerprint
Timestamp
Example · 2026-10-02T09:33Z
Capabilities
Bash · Read
Revocation
Active

Verifiedguard@v1

Illustrative object

Ask before the failed edit runs again

A policy match evaluated outside the LLM before the action reaches execution.

State / trust
Verified · L2
Version
1
Signature
sha256:19…de
Evidence
4 receipts
Source
Failed Edit action
Timestamp
Example · 2026-10-02T09:34Z
Capabilities
Edit · approval
Revocation
Active

Boundevidence_receipt

Illustrative object

pytest -q exited 0

A deterministic observation bound to the exact object version it supports.

State / trust
Bound · supporting
Version
1
Signature
sha256:34…a8
Evidence
Self
Source
Local verifier
Timestamp
Example · 2026-10-02T09:31Z
Capabilities
None
Revocation
Inherited

Immutableprovenance_record

Illustrative object

Session → candidate → verified object

The source event hashes and promotion decisions remain inspectable end to end.

State / trust
Immutable chain
Version
1
Signature
sha256:82…f1
Evidence
4 linked
Source
session_7f2
Timestamp
Example · 2026-10-02T09:32Z
Capabilities
None
Revocation
Preserved

Passverification_result

Illustrative object

Deterministic and replay checks agree

Verifier disagreement would hold the candidate instead of promoting it.

State / trust
Pass · gate 1
Version
1
Signature
sha256:aa…43
Evidence
4 inputs
Source
Local verify job
Timestamp
Example · 2026-10-02T09:32Z
Capabilities
None
Revocation
Bound to object

Revokedrevocation_tombstone

Illustrative object

The object is gone from recall—not from history

Identity, version, reason, and provenance remain so stale copies cannot silently return.

State / trust
Revoked · exit
Version
2
Signature
sha256:0d…7a
Evidence
Reason receipt
Source
Workspace owner
Timestamp
Example · 2026-10-02T10:02Z
Capabilities
None
Revocation
Terminal

08 Data boundary

Your code stays on your machine.

The cloud API has no raw-trace upload route. Classification and egress checks enforce the data boundary.

Where each data class may live, on your machine and in the Agentevo cloud
Class Examples Rule Your machine Agentevo cloud
C0 SDK versions, public schemas Anywhere Local Allowed
C1 Tenant IDs, plan, counters The only default cloud payload Local Default payload
C2 Step templates, fingerprints Opt-in sync, tenant-scoped, signed Local Not synced Full steps · E2EE Sanitized templates Your VPC
C3 Prompts, code, diffs, logs Local or your VPC only Local No endpoint
C4 Secrets, tokens, keys Never a valid payload, anywhere Redacted first Never valid

Privacy mode

Privacy mode

Local-only: the cloud sees control metadata (C1) and nothing else. Opaque Relay: full skill steps travel end-to-end encrypted. The cloud stores sealed envelopes it cannot read; your devices index and decrypt locally. Searchable Sync: only sanitized step templates and fingerprints leave, so the server can search them. File contents, diffs, command output, prompts and absolute paths stay on your machine. Customer VPC: the same contract, your keys, your indexes, your boundary.

  • Retrieved memory is never privileged instruction
  • Tenant and workspace come from the authenticated principal
  • High-risk auto-execution fails closed on stale policy
  • Initialized projects recall locally by default, offline and at quota; --cloud explicitly selects managed recall
Local guard p95
<50ms target · local fixture 0.11ms
Cloud recall p95
<250ms target
Raw-trace endpoints
0 in the cloud

09 Release evidence

Proof lives in the release record.

These are repository-verified engineering results, not customer benchmarks. AgentEvo does not publish adoption, savings, or customer claims until owner-verified data exists.

Test suite12,523 passed

October 18 local Python candidate: 32 skips, zero failures, 100% statements/branches. Production acceptance remains open.

Inspect QA results
Acceptance32 / 32

Spec acceptance cases automated across the product, data-flow, and API security matrices.

Inspect acceptance
Isolation26 tables

130 targeted tenant CRUD/upsert canary checks, alongside API scope/isolation fixtures.

Inspect isolation coverage
Raw-trace API0 endpoints

C3 prompts, code, diffs, and logs have no default AgentEvo cloud path.

Inspect threat model

Measured local fixtures Cloud recall still a target

Local guard
<50ms p95 · fixture 0.11ms
Local recall
<80ms p95 · fixture 3.1ms
Cloud recall
<250ms p95 target
Local continuity
Offline and at quota

10 Plans

Free while you build.

Free is live today, and its monthly allowance is a product guarantee. Pro and Team are coming soon. Nothing here asks for a card.

Free

Live

$0/mo

For solo builders

10,000 cloud requests / monthNever overages

  • Local runtime, unlimited
  • 1 user · 1 workspace
  • Counted cloud calls pause at quota; local keeps working
1 request
One batched call, up to 100 events
Never billed
Local work, usage reads, job polling
Start locally

Enterprise

Your boundary, your keys

Enterprise pilots: discuss self-hosted deployment and required identity, key, residency and support controls. Additional controls are planned and scoped per pilot.

Book a pilot

11 Field notes

Before you install.

Something else? support@agentevo.sh

VerificationWhat makes a skill Trusted?

Evidence first, then policy. A Candidate becomes Verified when deterministic checks back it: the agent's own test run, exit codes, CI. If verifiers disagree, it is not promoted. Trusted asks for more: by default three independent passing runs (five for destructive actions), still fresh and compatible, plus a human approval for high-risk work. A signature proves who made an object, never that it is safe to reuse.

SecurityWhat happens when a skill goes stale or is revoked?

Stale and revoked versions are withheld from relevant local use. A reviewed context profile records selected file and runtime fingerprints; legacy or unobserved context can remain UNKNOWN. Drift scanning and fresh revalidation support review. High-risk actions require current compatibility and policy checks. Revocation writes a tombstone; peers receive it when they sync, so an offline peer can lag.

Data & privacyWhat does cloud sync actually send?

Captured raw traces stay in your encrypted local vault; sync has no raw-trace upload route. By default the cloud sees control metadata only: IDs, plan and request counters. Searchable Sync adds sanitized step templates and fingerprints; file contents, diffs, command output, prompts and absolute paths stay on your machine. Opaque Relay sends full steps, end-to-end encrypted. Cloud copies show their own cloud_state and reach Trusted only with independent evidence from your devices. Explicit cloud recall sends your query and any selected sanitized failure context; optional BYOK embeddings also send selected text to your model provider. Sync is off until you turn it on under the sync terms:

agentevo login
agentevo sync mode --set searchable --terms-version 2026-09-21 --yes
agentevo sync push
agentevo recall "fix flaky test" --capabilities Bash,Edit,Read --cloud
IntegrationsWhich agents work with Agentevo?

Claude Code ships today: --latest finds your newest session on its own. Codex is in beta and reads sessions exported to Agentevo's Codex JSONL format, not Codex's own session files yet. Cursor, OpenCode, and CI join them through capture --adapter cursor|opencode|ci, all over Agentevo-defined JSONL contracts — the adapters never read proprietary session stores. QA / security agents are next. Adapters must pass conformance fixtures, and a connector update can never silently raise classification or permissions. The local guard targets p95 under 50ms and works offline. Compilation and verification are separate operations; configured host hooks and selected test replay can add session latency.

ProductDo I need Agentevo's models?

No. Model inference is bring-your-own-key by default: your agent keeps using its own provider and keys. The honest boundary: local-first governs data sent to Agentevo. Your agent's own calls to its model provider are a separate disclosure.

PricingWhat happens when I hit my quota?

On Free, counted cloud operations pause and everything local keeps working: capture, guard and the registry. Cloud recall pauses too — re-run with explicit --offline to search this machine's index instead. Export, deletion and revocation remain available at quota. Free never bills overages. Paid-plan limits and billing options will be published when available.

DeploymentCan Agentevo run without the hosted cloud?

Yes. Capture, compile, local verification, promotion, guard, and the registry work locally. Initialized projects recall locally by default; --offline also selects local recall outside them. Explicit --cloud needs Searchable Sync; Opaque Relay transfers encrypted objects for local indexing and recall after pull. Customer-controlled deployment can be scoped in an enterprise pilot. Public-cloud sync is opt-in and not required for the core learning loop.

EnterpriseHow do enterprise controls change execution?

Enterprise pilots can scope customer-controlled deployment and additional controls. Availability is agreed per pilot; the local guard still applies. Destructive actions require the configured evidence and approval gates.

Ready when you are

Your agents are already learning. Start shipping what they learn.

Start with the pinned CLI and bundled skills. Capture locally, inspect verification evidence and promote useful advice explicitly. Configure supported host guards to check proposed effects.

Questions first? support@agentevo.sh

Manual learning recipe After a completed task
get started · local-only by default
Release 0.2.9 · no install step: npx fetches the pinned CLI on first runnpx @agentevo-cli/agentevo@0.2.9 skills installnpx @agentevo-cli/agentevo@0.2.9 initnpx @agentevo-cli/agentevo@0.2.9 doctornpx @agentevo-cli/agentevo@0.2.9 capture --latestnpx @agentevo-cli/agentevo@0.2.9 compile --latestnpx @agentevo-cli/agentevo@0.2.9 verify --latest --local --workdir .npx @agentevo-cli/agentevo@0.2.9 promote --latest --to Verified --localnpx @agentevo-cli/agentevo@0.2.9 recall "fix flaky test" --capabilities Bash,Edit,Readnpx @agentevo-cli/agentevo@0.2.9 reportUse a completed Claude session here; inspect evidence before promotion. Report writes your measured reuse to agentevo-report.html.