How To Create A Personal Zero Human Trading Firm

Summary of the video (tech concepts + Paperclip “zero-human” firm)

The video argues that AI can already run trading-related workflows autonomously (24/7) and proposes building a “zero-human company”—more precisely, an AI team where humans define the agents’ goals, constraints, and “taste.”

The focus is Paperclip, an open-source AI agent orchestration framework (mentioned as having ~50,000 GitHub stars in the interview).

---

What Paperclip is / what it does

Paperclip is AI agent orchestration / management software that helps you build an organization of multiple agents, not just a single agent.

It provides accountability + structure, enabling you to:

• inject your preferences (“taste”)
• delegate tasks to agents
• coordinate work across “departments” (e.g., CEO/CTO plus specialized teams)
• maintain organization-wide context (tools, dashboards, branding, internal knowledge)

The video frames Paperclip as supporting an end-to-end trading firm architecture, including:

• research (idea generation)
• backtesting
• risk management
• strategy retirement when edges degrade
• trade execution even when you’re not actively present

---

How to use / setup (tutorial aspects)

The setup flow is presented as simple (including a one-command install) with a link to paperclip.ing.

Onboarding includes:

• naming your “company”
• creating the first agent (suggested default: CEO agent)
• running an environment check
• delegating an initial task/roadmap

Interaction methods mentioned:

• Web/UI for observing org charts, projects, issues, and runs
• Terminal/CEO “agent surface” automation, including:
  • a local voice transcription example
  • direct orchestration via tools like Claude Code
• use of different agent harnesses (e.g., Codex / Claude Code / other variants such as “OpenClaw” / “Hermes,” etc., as referenced)

---

Key product features highlighted

1) Org chart + role structure

Paperclip’s UI shows departments (e.g., CEO/CTO) and multiple agents under roles. The demo emphasizes the coding department under a CTO.

2) Bring-your-own agent / agent integration

You can integrate many different LLM agents / harnesses into a single Paperclip organization so they can communicate.

3) Projects, issues, and routines

Example routine ideas include:

• syncing Twitter bookmarks daily
• producing reports
• (later idea mentioned) turning liked ideas into actionable issues/tasks

4) Routines + iterative learning via history

An example workflow: delegate creation of a marketing video to a “video editor” agent with skills, then improve future outputs by learning from past creation history (e.g., correcting recurring “cut length” mistakes).

5) Reviewers and approvers for critical tasks

For high-stakes steps, agents can have their outputs checked by reviewer/approver agents.

Tradeoff noted: this increases token cost, but it’s presented as important for mission-critical workflows (e.g., verifying backtesting hygiene and risk).

6) Skills management (skills.sh integration)

Agents need capability through “skills” (e.g., an agent browser skill for browsing).

Strong recommendation: build solid skills wrappers for recurring real-world actions like:

• exchange trading
• data gathering
• QA tools

7) Concurrency controls

Runs can be queued by default, with a setting for max concurrent runs (the demo notes this may be buggy).

8) Agent “surface” (programmable control plane)

Paperclip exposes an agent surface for tasks like:

• creating/closing issues
• comments
• projects
• artifacts
• goals
• hiring
• skills

This enables CEO-mode orchestration through terminal harnesses.

---

Trading-firm architecture example (“Lewis Ventures” concept)

A conceptual workflow for an automated hedge-fund-style firm:

• Create an org with a CEO agent.
• Delegate tasks such as:
  • strategy research and data gathering (including sources like YouTube/transcripts and multiple inputs)
  • backtesting
  • building an execution layer
  • risk management and compliance logging/accounting
  • ability to retire strategies when performance degrades

The video stresses that more agents isn’t automatically better—start small (e.g., research, backtesting, red team, risk management, execution/deployment).

---

Advice and analysis given (important cautions)

Human “taste” is required

Agents can generate outputs freely, but you must encode preferences and evaluation standards via:

• instructions
• workflows
• skills

Hard risk constraints should not rely on the LLM alone

Example: LLM-based agents may forget, misunderstand, or attempt to circumvent constraints.

Mitigation (in principle) recommended: enforce risk constraints in hard code / separate services. Caution added: if agents are able to redeploy or modify enforcement mechanisms, they may bypass them (prompt injection / “LLMs are like children” analogy).

Paperclip is not a code review tool

Paperclip is positioned as managing outcomes/projects, while PR/code review tools (e.g., GitHub/Cursor workflows) handle code checks externally.

Backtesting hygiene matters

The video mentions metrics such as Sharpe ratio and discusses strategy-crossing demos (e.g., moving-average cross approaches). It encourages using well-tested backtesting libraries rather than reinventing everything unless doing advanced work.

---

Tutorial “how to build” style takeaways (explicit)

Use Paperclip to:

1. install
2. create an org
3. integrate chosen agent harnesses
4. define an initial roadmap (research → backtest → risk → execution)
5. add reviewer/approver layers for critical stages
6. provide required capabilities via skills
7. iterate using logs/history to refine agent instructions over time
8. start small and scale incrementally as bottlenecks emerge

---

Main speakers / sources

• Dota — founder of Paperclip (main interviewee/demo presenter; also mentioned anonymity by choice)
• Interview host (unnamed in subtitles) — asked breakdown questions and referenced prior trading-agent guidance; appeared as the other main speaker