Agentic Lending Morpho

This is the execution-capable Morpho workflow skill.

It is the Morpho-side counterpart to the EVK skill. It is still more conservative than the EVK path, but it now supports a real end-to-end flow for compatible requests: resolve the requested collateral and borrow assets, check feed readiness, execute funding when available, deploy the oracle adapter, deploy the Morpho market, and verify the result.

This published skill carries its own local runtime and bundled planning artifacts under scripts/lib/ and data/part2/ rather than assuming a separate repo checkout is available at execution time.

It should script as much of the Morpho path as the code can honestly support: feed readiness classification, executable funding, communal proxy deployment when needed, propagation rechecks, adapter deployment, market deployment, verification, resumable artifacts, and a generated rollback-plan.json for every orchestrated run.

When the supported path is available and the user explicitly asks for it, this variant can send real transactions and should be treated as a guarded execution skill rather than a planning-only helper.

Golden path for normal use

Use one request file and one wrapper command. Do not pick lower-level commands unless debugging or resuming a known run.

1. Create request.json with exact collateralAssets, exact borrowAssets, chain, RPC, Morpho policy, feed-funding intent, and send/broadcast intent.
• For a live-shaped Arbitrum WETH/USDC example, copy references/live-request-template.json and replace every placeholder before use.
• Never paste a raw private key into chat. For live execution, point the request at a local environment variable such as LIVE_SIGNER_ENV via feedFunding.privateKeyEnv / send.privateKeyEnv.
2. Preflight before live-capable execution:

agentic-lending-morpho preflight-morpho-market --input-file ./request.json --format json

Stop unless safeToRun === true. Preflight rejects placeholder RPCs, dummy addresses, dummy private keys, mismatched RPC chain IDs, and missing live deployment policy.

1. Run:

agentic-lending-morpho ensure-feeds-and-deploy-morpho-market --input-file ./request.json --format json

• The wrapper now emits phase-by-phase progress on stderr for preflight, feed classification, funding/handoff, propagation wait, deployment, and verification.
• Use --progress jsonl for machine-readable progress or --progress silent to suppress live progress output.

1. Inspect the persisted run directory, especially approval-summary.json, agent-decision.json, summary.json, rollback-plan.json, and progress-events.jsonl.
• approval-summary.json is the explicit handoff artifact for user approval: what will run, whether it may send txs, expected duration, and likely resource impact.
2. Report full success only when phase === "completed", there are no hard blockers, and verifyResult.verified === true.

If the run needs continuation, resume the same run directory rather than reconstructing state from memory:

agentic-lending-morpho ensure-feeds-and-deploy-morpho-market --resume-from-run-dir --input-file /request.json --format json

Timeouts and stalls should now name the stalled phase and point back to --resume-from-run-dir when that is the right recovery path.

Safety expectations

• default to planning, dry-run, or guarded verification first
• only use signer-backed feed funding or market deployment when the user explicitly asks for it
• treat browser-assisted funding as an explicit handoff, not a silent autonomous path
• require exact asset selection before deployment planning or submission
• require a usable RPC endpoint for any on-chain verification claim
• never ask the user to paste a raw private key into chat
• keep signer material in environment variables or local runtime config, never in committed files or request templates

Read next

1. references/workflow.md
2. references/current_capabilities.md
3. references/morpho-oracle-adapter.md
4. references/state-machine.md when feed activation and market deployment are both in scope
5. references/summary-contract.md before interpreting wrapper output or claiming success

Minimum required inputs

Gather these before attempting a Morpho-first workflow:

• chain name and chain id
• explicit collateralAssets
• explicit borrowAssets
• target market shape or risk intent
• whether the user wants planning only, dry-run, or transaction submission
• live RPC availability for the chain if anything beyond planning is expected
• Morpho policy inputs needed for deployment on that chain when transaction submission is requested

If any of those are missing, stop and ask instead of inventing them.

Request-shape rule

When preparing a request for this skill, always express the market assets explicitly as:

• collateralAssets: array of { symbol, address }
• borrowAssets: array of { symbol, address }

Do not leave asset selection implicit. The planner needs the exact collateral and borrow assets in order to resolve feeds, choose a direct-versus-composed oracle route, and verify the final market correctly.

For live execution, also include explicit activationMode, executionMode, rpcPreference, morphoCoreAddress, morphoPolicy, feedFunding, send, and broadcast fields. Use references/live-request-template.json as the starting shape, and check references/deployment-packs// for chain-specific operator notes. Never use placeholder RPC URL, raw private keys, signer address, Morpho core address, IRM address, or LLTV without replacing and validating them.

Default workflow

1. Normalize the request into:
• chain
• collateralAssets
• borrowAssets
• protocol = morpho
• market or risk intent
• desired execution mode
2. Treat asset selection as a first-class input.
• confirm the exact collateral asset set and borrow asset set the user wants
• for multiple collateral assets, remember this becomes a Morpho market set: one market per supported collateral/borrow pair
3. Resolve the oracle path before any deploy step.
• prefer a direct pair when the exact requested route is available and usable
• otherwise use a supported composed route when the planner can prove it cleanly
• keep feed-name matching generic: literal exact pair first, alias-normalized fallback second
4. Check feed readiness before deployment.
• if feeds are already live on the deployable on-chain path, continue
• if funding is needed and executable, run the funding path first
• if funding executes, wait for live propagation/readability before deployment
• if the funding branch is browser-assisted or unsupported, stop and report that honestly instead of pretending transaction submission can continue
5. Prefer the orchestration wrapper for the real sequence.
• use ensure-feeds-and-deploy-morpho-market when the goal is to check feeds, fund if needed, deploy communal proxies when needed, wait for propagation, deploy, verify, and persist one coherent run directory
• use lower-level commands only when debugging or resuming a prior run
6. Prepare and deploy the Morpho oracle adapter path.
• use the Api3-backed Morpho oracle adapter design as the canonical oracle shape
• preserve artifact handoff from adapter deployment into market deployment
• keep proxy-first ordering whenever a communal proxy deploy is required
• verify the adapter uses the same feed/proxy sources that were proven live
7. Verify the deployed market.
• confirm the market exists on-chain
• confirm params, IRM, and LLTV expectations
• confirm oracle price() succeeds and is positive
8. Stop at the honest boundary.
• if the request can only reach planning or funding handoff, say so clearly
• do not present Morpho deployment as equivalent to the EVK live deploy path unless the code actually supports the requested environment
• do not treat feed discovery, funding readiness, adapter design readiness, deployment readiness, and verified market creation as the same milestone

Preferred command path

For a deployable request, prefer this command shape:

agentic-lending-morpho ensure-feeds-and-deploy-morpho-market --input-file ./request.json

Use it when the agent already has a concrete request file with the selected collateral and borrow assets.

Use --resume-from-run-dir