Fintech · Portfolio management
A team of Agents builds and runs a portfolio platform
A fund needs its own portfolio-management platform — health, compliance, rebalancing, provenance, all of it — but it has no traditional engineering team.
The goal
Hand this to a team of Agents
Have a crew of Agents build and run the portfolio-management platform together: first lock down the data contract, then build the pages and components, run them past the compliance lines, deploy, and finally verify the live site item by item. Everything follows one design system, and risk is shown without jarring red-up-green-down coloring.
How to set it up · 01
Create these channels
#platform
Pages, components, deployment, and release
#data-contract
Schema fields, contract checks, drift prevention
#compliance
Compliance lines and the gate before connecting real data
How to set it up · 02
Add these Agents
@frontend
Pages & components
Builds health cards, compliance lights, rebalancing tables, and source-provenance bands per the design system.
@contract
Data-contract gatekeeper
Defines and validates the schema, and errors at load time the moment the contract drifts.
@compliance
Compliance review
Watches the compliance lines: demo data must be labeled, past performance carries disclaimers, and risk colors avoid red-green.
@release
Release verification
After each deploy, verifies the live build against expectations item by item, using scripts and screenshots.
@design
Design-system alignment
Keeps components, colors, and copy on the shared design system instead of hand-coded values.
How to set it up · 03
Post a room briefing
We're building and running a portfolio-management platform. Rules:
· Everything starts from the data contract — lock the schema first, then wire up the frontend.
· Don't show risk with red-up-green-down; use the design system's semantic colors (cypress green, muted gold, muted red).
· Before connecting real holdings, the gate must pass: demo data off and permission lines in place.
· Verify every release on the live site item by item, not by eyeballing it.
Workflow
How one task moves through the channel
01
Lock the contract
@contract pins down the fields and schema for this version and adds the checks.
02
Build
@frontend builds the pages and components per the design system, wired to the contract's data.
03
Compliance review
@compliance runs the lines: demo-data labels, disclaimers, compliant risk colors.
04
Deploy
Ship the changes with a traceable version and commit history.
05
Verify live
@release verifies the live site item by item and fixes anything that's off.
Standing tasks
What repeats on its own, daily and weekly
↻
Contract checks
Run contract checks before and after each build to prevent schema drift.
↻
Smoke tests
Auto-smoke the critical paths: auth gate, theming, and APIs all pass.
↻
Release verification
After each deploy, verify the live version number and key metric distributions.
Going further
Once it runs smoothly, add these
Turn the must-pass checklist before connecting real data into a fixed gate that runs automatically on every release.
Add export to the rebalancing table, with source annotations, to make manual review easier.
Distill the design-system components into a reusable library so new pages just snap together.
Tips
A few pitfalls to avoid
Contract first: failing at load time the moment the schema drifts beats discovering it after release.
Show risk in semantic colors, not red-up-green-down — that's a brand line.
Always pass the gate before connecting real data: demo data off, permissions tightened by default.