CellCog is built with CellCog. Every feature, every bug fix, every customer email, every document — all developed and managed with our own AI agents. This guide walks through the real setups we use every day, so you can see how to get the most out of the platform.
All of CellCog's intelligence needs are handled by CellCog agents. We make very few exceptions. The only AI tool we use is the one we're building — which means we feel every rough edge, and we fix them because we need them fixed ourselves.
Every setup below describes real workflows we run daily, including the specific tools and connections we use.
You'll notice something across all our setups: almost every one connects to our main repository via Cowork. This isn't accidental — it's the most important architectural decision we've made for working with AI agents.
We've been carefully developing our main repository to be a single source of truth for the entire company. It hosts:
By keeping everything in one structured place, we only need to make one connection (Cowork → main repository) and the agent has access to virtually everything about the company. It can research our codebase, read our docs, check our brand guidelines, understand our infrastructure — all from a single working directory.
This is what makes the setups below surprisingly simple. The connections look minimal (often just "Cowork on our main repository"), but the real power is in what that repository contains. The more structured and comprehensive your repository is, the more capable your agents become.
Mode: Agent
Connections: Cowork on our main repository
This is our primary development workflow. Here's how it works:
The developer acts as a co-pilot — providing feedback, testing changes in the browser, sharing screenshots, and guiding direction. The agent writes the code, the human validates it works.
A single coding session often spans multiple roles. The same agent naturally transitions through:
We don't switch agents between these roles — the same session handles all of them because the agent has full context of everything that's happened.
Once development is done, the same agent also drafts the product update blog post. Since it has deep context of exactly what was built and why, it produces highly specific, accurate marketing content. This is one of the unexpected benefits of single-session multi-role work — the agent that built the feature is the best one to announce it.
In the early days, we reviewed every single command the agent wanted to run on our machines — including reads. This was invaluable for understanding how agents think and building trust.
Now we've relaxed: we auto-approve reads and writes inside the git-tracked repo. But we still review all terminal commands and anything outside the working directory.
Our recommendation: Start cautious. Review everything. As you build confidence in how the agent operates, gradually relax your auto-approve settings. If you're working outside a git repo, always review every command.
Mode: Agent
Connections: Cowork on our main repository
Some features are too large for a single session. Our billing system took 8-9 sessions. When this happens, we manage a careful handover process:
We develop on a feature branch (not the main branch). This is critical for the multi-session strategy because it gives each new session a clear way to understand what changed.
Ending a session:
Starting the next session:
These documents get continuously updated across sessions — each session appends its progress to the design doc and updates the handover doc with remaining work.
The three inputs give the new session a complete picture:
Session 5 doesn't need to rediscover what sessions 1-4 built — it reads the design doc, understands the remaining work from the handover, and sees exactly what code was written via git diff.
Multi-session development is inherently more expensive. A significant portion of tokens in session 2+ is spent on the agent understanding previous work — reading docs, analyzing git diffs, building context. This is expected and intentional. We optimize for accuracy over cost, because the cost of bugs in production is always higher than the cost of thorough context-loading.
Tip: Ask the agent to "critically self-review" the design doc before ending a session. This catches inconsistencies and ensures the next session gets clean context.
Mode: Agent Team or Agent Team Max
Connections: Cowork on our main repository
For our most complex engineering challenges, we combine Agent Team mode with Cowork. This gives us a deep research coding agent — multiple agents that research deeply, debate approaches, and then implement directly in our codebase.
We used this setup to improve our own deep research protocols. The agents analyzed our existing system, researched cutting-edge techniques, and then implemented improvements — essentially improving themselves.
This is a unique capability: a deep reasoning, multi-agent system that can simultaneously research state-of-the-art approaches AND write production code. To our knowledge, no other platform combines deep research with direct code execution in a single workflow.
Mode: Agent
Connections: Gmail + Cowork on our main repository
This is how we handle customer emails — including the one that inspired this entire documentation effort.
Customer questions often require deep understanding of how the product actually works — not just what the docs say. By giving the agent access to both the email and the codebase, it can trace a customer's confusion to the actual implementation and provide precise answers.
Some customer emails arrive in different languages. The agent reads them, researches in English, and drafts responses in both the customer's language and English.
For complex queries, the agent sometimes identifies that the best response isn't just an answer — it's a product improvement. In those cases, the agent makes foundational changes to the codebase first, then drafts the response referencing what was fixed.
Mode: Agent
Connections: Cowork on a docs folder
Project: CellCog Docs Management
Agent Role: Global Sales Tax Expert
We use CellCog for managing legal and compliance documents — company incorporation filings, sales tax registrations, state-specific forms, and more.
It works like having a legal assistant who knows your entire document history. The agent role's memory accumulates knowledge about our specific filings, deadlines, and jurisdiction requirements across sessions.
We still work with actual legal counsel for complex matters, but this agent handles the bulk of the operational work with high accuracy.
Mode: Agent
Connections: Cowork on our main repository
When we need to analyze production data, we don't use a separate analytics platform — we use CellCog.
Important: We review database scripts very carefully. The agent writes the script, we verify it's read-only, then we approve it via Cowork. For any write operations (like migrations), we review line by line.
Surface: AI Employees
Connections: Cowork on our main repository + Gmail
Beyond interactive chats, we hire AI employees for standing, recurring work that shouldn't wait for a human to start it. An AI employee runs on its own schedule, has its own inbox, and keeps a task board and memory across shifts.
A scheduled chat runs a prompt on a timer and forgets. An AI employee accumulates context across shifts, follows up on its own observations, maintains dashboards of what it's tracking, and can hand work to another employee — so recurring operational work actually compounds instead of restarting each time.
One of our most-used prompts across all setups:
"Can you critically self-review your [plan / design / changes]?"
We use this at critical junctures — after creating a plan, after making significant code changes, after drafting a response. The agent re-examines its own work with a critical eye and often catches issues it missed on the first pass.
We strongly recommend this for any high-stakes work. It's a simple prompt that meaningfully improves accuracy. Use it after plans, after designs, after implementations — especially when the cost of getting it wrong is high.
| Setup | Mode | Connections | Use Case |
|---|---|---|---|
| Coding Agent | Agent | Cowork (repo) | Feature development, bug fixes, product updates |
| Multi-Session Dev | Agent | Cowork (repo) | Large features spanning 3-9 sessions |
| Deep Research Coding | Agent Team / Max | Cowork (repo) | Complex architecture, self-improvement, cutting-edge work |
| Customer Support | Agent | Gmail + Cowork (repo) | Reading & responding to customer emails with codebase research |
| Document Management | Agent | Cowork (docs folder) + Project + Agent Role | Legal filings, tax compliance, document guidance |
| Data Analysis | Agent | Cowork (repo) | Production database analysis, PDF report generation |
| AI Employee | AI Employees | Cowork (repo) + Gmail | Standing, scheduled work with its own inbox, shifts, and memory |
Cowork is the foundation. Almost every setup starts with connecting your working directory. It gives agents intimate access to your real environment.
One session, many roles. Don't switch agents for each phase of work. A single session can be your PM, engineer, security reviewer, and marketing writer — and it does better because it has full context.
Multi-session handovers matter. For large projects, invest in proper design docs and handover documents. Each session should leave the next one better informed.
"Critically self-review" is your best friend. Use it liberally. It's the single highest-impact prompting technique we've found.
Start cautious with command review. Review everything at first. Relax as you build trust. Never auto-approve commands outside your git repo without understanding what they do.
The agent that builds it should announce it. Post-development marketing from the same session produces remarkably specific, accurate content.