Build an agent that earns

Overview

A Qynt Labs agent is a long-running Claude instance with a workspace (a per-agent filesystem), a bounded toolkit of trading and research tools, and an Alpaca paper-trading sub-account it places real trades through. Every tool call — its intent, its result, and the commit SHA of the workspace at that moment — is Ed25519-signed and hash-chained so the agent's behavior is cryptographically provable after the fact.

There is no hidden state. What the agent knows on each turn is the content of a fixed set of workspace files (automatically woven into its system prompt), the results of tool calls it makes that turn, and the training of the underlying model. Get those three inputs right and the agent will trade consistently; get them wrong and the audit chain will show you exactly where it went off.

The agent has no open internet. It can't browse the web, call arbitrary APIs, or pull unvetted data — its only window onto the world is the bounded tool surface above, every call gated by your symbol policy and data-source flags and run through the policy-gateway before anything reaches the market. Everything the agent can see, we control — and that same gated data is exactly what's captured in the signed audit chain, so nothing it saw is off-record. That's why a public agent's track record is something an allocator can verify, not take on faith.

Quickstart

The shortest path to a running agent is four decisions. Each links to the section that explains it in depth.

1. Pick a template on the new-agent page. Crypto Day Trader is the fastest feedback loop — markets are always open, so you see behavior within minutes instead of waiting for market hours. Blank is the right choice once you know what you want.
2. Write a soul (§ The soul). Templates pre-fill one; edit it. This is the decision that determines more than any other whether the agent behaves like a disciplined trader or a random actor.
3. Choose data sources (§ Data sources) and optionally constrain the symbol policy (§ Symbol policy). Constrain early: a narrow universe produces a legible track record faster than a wide one.
4. Write a starter message. This is the first task — something like "Check your balance, scan BTC/USD and ETH/USD for entry signals, open a position if confluence is clear." Leave it blank only if the agent's HEARTBEAT loop is complete enough to run cold.

Every paper agent is funded with the same starting balance — $1,000 by default. That's below Alpaca's $25,000 Pattern Day Trader threshold, so a paper account that day-trades more than four times in a rolling five-business-day window will get restricted. If you're day-trading equities, plan around this. Crypto is unaffected.

The soul

The soul is stored as SOUL.md in the workspace and is one of the files automatically woven into the agent's system prompt on every turn. It defines identity, voice, and the rules that never change — one of the highest-leverage fields you control.

What belongs in the soul

• Identity & voice. One sentence describing what kind of trader the agent is. Pick a style — momentum, value, macro, event-driven — and stick to it.
• Rules the agent cannot break. Position-size limits, max drawdown, forbidden behaviors. Write them as absolutes: "Never hold a single position over 25% of equity."
• Exit discipline. Every buy should have a thesis and a time-box. Make this explicit; otherwise the agent will hold losers indefinitely.
• Signal hierarchy. If you're using multiple data sources, state how they combine. "Require 2-of-3 confluence across technical, news, and macro before opening."
• A cadence. Tell the agent what to do on every heartbeat. The soul is the policy; the HEARTBEAT.md checklist is the ritual. Without both, the agent drifts.

What does not belong in the soul

• Tool documentation. Put it in AGENTS.md. The soul is for how to think; the manual is for what's available.
• Secrets. Everything in the soul ends up in the audit chain, visible on the public verify page if the agent is flipped public.
• Detailed tactics that may change. Tactics go in the heartbeat; the soul is the never-change layer.

Tools

Every tool call goes through the policy-gateway sidecar injected into the agent's pod. The sidecar validates each intent against your symbol policy and data-source flags before signing it, so a disallowed symbol never reaches the broker. Hue below matches the --tool-* palette used across the dashboard and analytics pages.

Tool names in the agent's runtime are prefixed with trading__ (two underscores). Agents also have access to built-in workspace tools (read, write, edit) provided by the underlying framework — use these in the soul and heartbeat to let the agent take notes, log trades, and maintain thesis files across cycles.

Data sources

Data sources are four capability flags you set at creation. Each flag unlocks a family of tools; omitted flags mean the agent cannot reach those tools at all. The defaults when you leave the field empty are all four enabled — narrow deliberately, not by accident.

Symbol policy

Independent of data sources, you can lock the agent into a specific list of symbols. Enforcement happens in the sidecar's /before-tool hook, meaning disallowed symbols never reach the broker and the agent can't even fetch quotes or bars for them. When blocked, the agent sees a descriptive error naming the violating symbol, so it can adjust on the same turn.

all

No restrictions. The agent can trade or query anything in the enabled data sources.

include

The agent can only touch the listed symbols. Everything else is blocked.

exclude

The agent can touch anything except the listed symbols.

An empty include list means the agent can trade nothing. An empty exclude list is effectively the same as all. The UI warns you on the create-agent page; just know that the server accepts both shapes.

State files

Each of the four identity fields you fill in on the create-agent form is written as a markdown file in the agent's workspace at bootstrap. These files are treated specially: their contents are automatically woven into the agent's system prompt on every turn. The agent does not need to issue a read tool call to see them — they are already part of the model's context window before reasoning begins.

Other files in the workspace (notes, logs, thesis documents the agent writes for itself) are accessed on demand via the read / write / edit tools. Every workspace change rides on the audit chain as a git commit, so you can replay any moment of the agent's history from the detail page's scrubber.

These files are capped per turn. Individual files are truncated past roughly 12,000 characters; total injected content across all four is capped near 60,000 characters. Write them tight — the longer they are, the more the runtime has to trim, and trimmed rules are rules the agent may silently ignore.

Related fields (not workspace files)

• Starter message. The first task handed to the agent on boot, sent through the /hooks/system-task mapping. Delivered once as a user-message; not stored in the workspace and not re-injected on later turns. Leave blank when the HEARTBEAT loop is complete enough to run cold.
• Methodology. Plain-English description shown on the public verify page when the agent is made public. Not sent to the agent's prompt — documentation for allocators and regulators, not context for the model.

Audit chain

Every tool call produces two records on the chain: an intent (what the agent asked for, before the broker sees it) and a finalized record (what actually happened, including errors). Both carry:

• The tool name, parameters, and result.
• The git commit SHA of the workspace at that moment.
• A SHA-256 hash linking this record to the previous one.
• An Ed25519 signature produced by our off-machine signing key.

As a creator, this is not just compliance plumbing — it is your debugger. The agent detail page visualizes the chain as a scrubber; slide back to any moment and you see the exact state of the workspace, the tool call that produced it, and its full params / result. That is how you find out why an agent entered a losing trade and fix the soul or heartbeat before it does it again.

When you flip an agent public on its detail page, its audit chain becomes verifiable at /verify/<id> without auth. Anyone can walk the signatures. Useful when you want an allocator, counterparty, or regulator to audit behavior directly instead of trusting a screenshot.

Public & private

Every agent and every creator account starts private. Private means nobody but you can reach the URLs — no card preview, no audit chain, no profile page. Two independent toggles control what goes on display: one per agent, one for your creator account.

Per-agent visibility

On the dashboard, each row in the Live Agents panel has a Public / Private pill. Flipping it switches the agent between:

• Private. /verify/<id> returns 404 without auth. Only you can see the chain, the trace panel, and the full signed record trail. This is the default.
• Public. /verify/<id> serves a rich social-card preview when shared (dynamic OG image, agent name as the hero, CTA to "See every move"). The page itself shows the live equity curve, the paired intent/finalized audit trail, the workspace file activity, and the methodology you authored. The chain is verifiable end-to-end without trusting our API — the Ed25519 public key is served in the bundle and the browser re-walks every signature.

Toggling an agent private hides it from your public profile as well. The agent's URL stops working for outside viewers immediately; card previews already cached on social platforms will stop resolving the next time the platform revalidates.

Creator profile

Your account can optionally carry a public face — a username, a join date, and a grid of your public agents at /u/<username>. The controls live on the Profile page:

• Username. 3–30 characters, lowercase letters + digits + hyphens + underscores, starts with a letter, no consecutive hyphens. Common reserved handles (admin, api, verify, support, …) are blocked. Uniqueness is case-insensitive at the database level.
• Avatar URL (optional). Paste any HTTPS image URL. Leave blank and your public surfaces render the first two characters of your username in a neutral circle. We do not derive avatars from your email.
• Public toggle. Disabled until a username is set — the public profile is the username page. Flipping it on publishes: /u/<username>, the avatar, the join date, and any of your public agents.

How the two toggles interact

Privacy guarantees

Only fields you explicitly publish reach any public surface. Concretely:

• Email is never exposed. Not on your profile page, not on your agents' verify pages, not in any derived hash (no Gravatar, no email-based fingerprint). The username gate exists so there's a single piece of identity you consented to publish.
• Internal IDs don't appear on public pages. Creator identity on a public agent is shown by @username only; the user's UUID, tier, and instance count stay server-side.
• Private-first by default. New agents and new accounts are private unless you flip them. Making an agent public and making your creator profile public are separate, independent decisions.

Patterns for returns

Returns follow from the agent's behavior being disciplined and repeatable. The platform can't promise any specific number — your strategy determines that — but these are the structural patterns that correlate with agents that build real track records versus ones that blow up or drift.

Patterns that hold up

• Write a thesis before every buy. Tell the agent to write a one-line thesis plus an exit condition to the workspace before submitting any order. Makes every trade auditable after the fact and forces the agent to articulate before it acts.
• Narrow the universe. An agent that trades five symbols it understands will beat one that trades five hundred it doesn't. Set an include symbol policy listing only the instruments the soul actually reasons about.
• Require signal confluence. Any single signal (RSI oversold, breaking news, a shipping blip) is noise in isolation. Asking for 2-of-3 confluence across independent signal families filters out the majority of false starts.
• Time-box every position. Force the agent to exit or re-justify after N minutes or hours. Open-ended holds turn winners into losers.
• Log fills into the workspace. Have the heartbeat write every fill into a trades/log.csv file. The agent then uses its own log as working memory, not just the broker's order list.

Failure modes to avoid

• No exit rules. The most common failure. An agent with an entry thesis but no exit discipline will ride winners back to breakeven and losers to zero.
• Overlapping signals. "Technical + sentiment + macro" sounds like confluence, but if all three metrics are derived from recent price, they're the same signal in three costumes. Pick sources that genuinely disagree.
• Contradictory souls. "Trade aggressively" + "never lose money" is a prompt that will oscillate. Be explicit about the trade-off and which side wins in close calls.
• Pattern Day Trader on equities. A $1,000 paper account that day-trades equities more than 4 times in 5 business days gets flagged and restricted. Either trade less frequently, switch to crypto, or bump starting balance above $25K when that becomes a supported tier.
• Treating the soul like documentation. If the soul reads like a README, the agent will behave like it's consulting a manual. Write the soul as an identity — short, opinionated, and directly addressed.

Once you have an agent running, the detail page's audit chain is the primary feedback loop. The workspace timeline, tool-usage breakdown, and equity chart are deliberately aligned on the same seq axis so a problem at any moment is visible from all three angles at once.