Everything you need
to operate Corine.

01 — Product quickstart

From wallet connection to a running agent.

Start with one narrow mandate, a minimally funded agent wallet, and conservative authority. Expand only after you have reviewed real executions.

02 — Accounts & wallets

Identity, capital, and runtime are separate.

Corine keeps authentication, each agent's trading funds, and product credits distinct. Moving one balance never silently changes another.

Product surfaces

03 — Deploy

Turn a mandate into bounded authority.

The live preview is the contract you review before deployment. If the inferred asset, trigger, action, or limits differ from your intent, rewrite the prompt before proceeding.

Advanced settings

Availability depends on the exact token or market, wallet funding, route health, product feature flags, and selected capabilities. A visible category is not a promise that every requested asset has an executable route.

04 — Operate agents

Fund, observe, pause, and stop with intent.

Dashboard is the fleet view; each agent page is the source of truth for that runtime's status, wallet, parsed strategy, executions, and controls.

05 — Chat & Telegram

One conversation layer, scoped to your intent.

Use account-wide Chat for research and planning, or select a deployed agent to inspect its mandate, wallet, decisions, and activity directly.

Link Telegram

Never paste a private key or seed phrase into web chat, Telegram, or a support conversation.

06 — $CORINE & credits

Buy the runtime asset. Credit verified purchases.

$CORINE purchases add runtime credits after on-chain verification. They do not add SOL or tokens to an agent wallet.

Purchase multipliers

The multiplier applies to each complete verified purchase. Separate purchases are not combined into a higher tier. If automatic crediting does not appear, use Recover a completed purchase on the Buy $CORINE page and paste the confirmed signature. Verification is idempotent.

Current metering

The in-product price shown at confirmation is authoritative. Running out of credits can pause a metered agent even when its on-chain wallet is funded.

07 — Markets & research

Research, test, trade, and automate.

Corine's market surfaces serve different jobs. Missing fields remain unavailable rather than being filled with invented data.

08 — Product safety

Interpretation proposes. Deterministic policy decides.

Product intelligence can prepare an action, but the configured authority and runtime checks determine whether it may proceed.

Allow risky tokens

Open the agent page, then Strategy → Safety gates → Allow risky tokens. The switch bypasses warning-level checks only for that agent. Turning it on can expose the full permitted trade amount to token-specific loss. To restore screening, turn it off.

09 — Troubleshooting

Diagnose the state before retrying.

Blind retries are dangerous in financial software. Start from the specific status, block reason, transaction signature, and wallet balance.

01 — The one idea

Nine gates, one order, no way around.

Every trade the SDK executes runs through a single function. It passes nine deterministic gates in a fixed order, then dispatches to a fill venue. A forker adds a venue by implementing an interface, and it still sits behind every gate. That is the moat, and the safety guarantee.

02 — Under five minutes

Configure with your keys, run a guarded trade.

Provide your RPC and your signer. Everything else has a safe default: an in memory store, a console notifier, and the Jupiter price, quote, and fill leg. Caps are required, so there is no way to run an uncapped trade.

import { createCorine, LocalSigner, SOL_MINT, USDC_MINT } from "@h4rsharma/corine-core";

const corine = createCorine({
  rpc: { endpoint: process.env.RPC_URL },                 // your RPC
  signer: LocalSigner.fromBase58(process.env.SECRET_KEY), // your key, stays local
});

const res = await corine.execute({
  inputMint: SOL_MINT,
  outputMint: USDC_MINT,
  amountUsd: 10,
  side: "buy",
  maxPerTxUsd: 100,   // required
  dailyCapUsd: 500,   // required
});

// "executed" | "blocked" | "failed" | "noop"
console.log(res.status, res.txHash ?? res.reason);

03 — The runtime

One call to configure, one method to trade.

createCorine(config) returns a runtime. The only way to move funds is corine.execute(), which always runs the spine. There is no raw, ungated execute exported anywhere in the package.

type BlockReason =
  | "kill_switch"  | "over_caps"      | "over_daily_cap"
  | "below_min"    | "insufficient_sol" | "stale_trigger"
  | "stale_price"  | "rug"            | "not_whitelisted"
  | "inflight"     | "internal";

04 — The seams

Pluggable infrastructure. Your keys, your providers.

The runtime depends on interfaces, never on a concrete provider or endpoint. Each ships a working default, and you swap in your own with minimal friction. No Corine secret lives in the package.

import { createCorine, LocalSigner, FileStore } from "@h4rsharma/corine-core";

const corine = createCorine({
  rpc:     { endpoint: process.env.RPC_URL },
  signer:  LocalSigner.fromBase58(process.env.SECRET_KEY),
  store:   new FileStore("./.corine/state.json"), // durable idempotency + caps
  jupiter: { apiKey: process.env.JUPITER_KEY },   // optional, your key
});

05 — Autonomy

Deploy an agent. It can only propose.

An agent type decides when to trade. The runtime executes the proposal through the spine with the agent's caps, so a handler cannot trade directly. Ships with DCA, dip buyer, limit order, and laddered exit, plus a pluggable registry for your own.

const agent = await corine.agents.deploy({
  userId: "me",
  strategy: {
    name: "BONK DCA",
    agentType: "DCA",
    outputMint: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
    amountUsd: 5,
    intervalSeconds: 3600,
    caps: { maxPerTxUsd: 10, dailyCapUsd: 50 }, // mandatory
  },
});

// call on your own schedule; returns a GuardedResult or null
await corine.agents.runOnce(agent.id);

06 — Terminal

The same spine, from your shell.

The CLI trades through the identical guarded spine. Human readable by default, structured on every command with --json, so agents and scripts consume it too. Your keys stay local. Money moving actions confirm by default.

Configuration

The CLI reads configuration from the environment. Network reads need an RPC endpoint; execution commands also require a local signer. help and docs work without either.

Global flags

$ corine buy --out EPjF…Dt1v --usd 999 --yes
✗ over_caps: Amount $999 exceeds the per-trade cap of $100.

$ corine kill on
Kill switch ON — all trades halted.

$ corine buy --out EPjF…Dt1v --usd 999 --json --yes
{"ok":false,"command":"buy","data":{"status":"blocked"},
 "error":{"code":"over_caps","message":"Amount $999 exceeds the per-trade cap of $100."}}

07 — Honest by policy

The safety model, without overclaims.

The guarantee this runtime makes is narrow and real. You cannot execute a trade that skips the gate stack. Everything else is your configuration and your disclosure.

08 — Boundaries

What is open, what stays hosted.

The open package is the complete, real runtime, not a teaser. You can install it, bring your keys, and run a guarded trade with nothing else. The runtime never requires billing. A trade is never credit gated.