The AI Stack Behind a Lean Studio: How We Run Marketing, Outreach & Ops on Agents

Aumiqx is small. Deliberately small. But the amount of work that flows through it — outbound campaigns, lead research, cold email, CRM hygiene, SEO content, deliverability monitoring — looks like the output of a full marketing and operations team.

The trick isn't working more hours. It's that almost every repetitive job in the business has an AI agent sitting behind it. Not a chatbot. An actual pipeline: something takes an input, reasons over it, calls the tools it needs, and hands back a finished artifact.

This is the real stack — the one running the company right now, not a demo. If you're a solopreneur or a lean studio trying to punch above your headcount, this is the honest version of how it fits together, what each piece costs, and where the sharp edges are.

The goal was never "automate everything." It was "never do the same boring thing twice."

Before the detail, here's the whole machine on one page. Every row is a job we used to do by hand.

Job	What runs it	Rough monthly cost
Reasoning & orchestration	Claude (Opus + Sonnet), model-routed	~$20–50 in API/usage
Lead sourcing	Custom Apify actor over Google Maps	Credits-based, ~$5–15
Email enrichment	Site-scrape + pattern fallback (in the same actor)	$0
CRM & knowledge base	Notion, driven over MCP	Existing plan
Sending & inbox	Zoho Mail, driven over MCP	Existing plan
Open/click tracking	Self-hosted PHP pixel with signed tokens	~$0 (shared host)
Content & SEO	Programmatic Next.js pages from TypeScript data	$0 (static export)

Notice what's not there: no Clay, no Apollo seat, no Smartlead subscription, no Hunter, no separate CRM SaaS. Every one of those got replaced by a small, owned piece of the stack. That's the whole thesis — own the primitives, glue them with an agent.

Cold outreach dies at the top of the funnel. If your list is garbage, nothing downstream matters. So the first agent in the stack does one job well: build a clean, relevant list of businesses that fit a specific profile.

We built a dynamic Apify actor — a thin wrapper around a proven Google Maps scraper. You hand it a vertical ("med spas"), a location ("London"), and a filter set (has a real website, rating range, review count), and it returns lead-ready JSON. Because it's parameterized, the same tool works for dentists in Austin or marketplaces in Berlin without touching a line of code.

The part that usually costs money — finding a contact email — happens for free inside the same run. For every business with a website, the actor fetches the homepage and common /contact paths, extracts any email it finds, and falls back to a sensible pattern (info@domain) only when it has to. That single step replaces a paid enrichment tool entirely.

Why a wrapper instead of a scraper

We could have hand-written a Playwright scraper. We didn't, on purpose. Maps scraping is a maintenance treadmill — selectors break, rate limits shift, layouts change. Delegating the brittle part to a maintained actor and keeping our logic (filters, shaping, enrichment) in a thin layer means the thing keeps working while we sleep. Boring, owned, and resilient beats clever and fragile.

You can write the perfect email and still land in spam. So a real chunk of the stack is just making sure mail actually arrives and that we know what happened after it did.

Sending runs through Zoho Mail, driven programmatically over MCP — the agent can draft, reply-in-thread, and search the inbox without us clicking around. But the piece we're proudest of is the tracker: a tiny self-hosted PHP endpoint that serves the tracking pixel and click redirects.

• Signed tokens — every open/click URL carries an HMAC-signed token, so nobody can forge or enumerate tracking events. Owned infra means no third-party pixel domain quietly degrading our sender reputation.
• Honest metrics — Apple Mail Privacy Protection and Gmail image prefetch inflate open rates across the whole industry. We treat opens as a weak signal and weight clicks and replies far more heavily. If your dashboard says 70% opens, it's lying to you.
• Owned, not rented — the tracker lives on our own subdomain. No Smartlead seat, no per-contact pricing, no data leaving our control.

Deliverability isn't a feature you buy. It's a discipline: warm domains, honest volume, clean lists, and metrics you don't lie to yourself with.

Every lead, reply, and collaboration request lands in Notion — but we almost never open Notion to write to it. The agent does. Over MCP, it can create pages, update statuses, dedupe records, and cross-link a new inbound reply to the original outbound thread.

That's the quiet superpower of wiring your tools to an agent: the CRM stops being a chore you fall behind on and becomes a side effect of work already happening. A reply comes in, gets read, gets classified, and the board updates — no human data entry in the loop.

The same pattern covers link-exchange requests, partnership inbound, and job-application tracking. One database schema, one agent, and the busywork of keeping records straight simply disappears.

The page you're reading is part of the same philosophy. This entire site is a static Next.js export generated from a few TypeScript data files. Add one object to a file, and the build produces a fully-formed page — with JSON-LD structured data (Article, Breadcrumb, FAQ), canonical URLs, meta tags, an entry in the sitemap, and internal links to related content. All automatic.

That means content scales without the usual CMS overhead. There's no headless CMS bill, no plugin sprawl, no "who has edit access" problem. The data is the content, version-controlled in git, and the build does the SEO plumbing every single time.

Why programmatic beats a page builder

• Structured data is guaranteed correct — it's generated from a schema, not hand-typed per page.
• A change to the article template updates every article at once.
• Static export means the whole site is CDN-fast and costs almost nothing to host.

For a lean team, that's the difference between publishing consistently and drowning in maintenance.

People always ask for the tool list, so here's the honest one — the things we open on a normal week, not a sponsored roundup.

• Claude — the reasoning engine behind almost everything. Opus for architecture and long-form writing, Sonnet for the day-to-day. Model routing keeps the bill low.
• Apify — the runtime for our custom lead-sourcing actor. Credits go a long way when you only run what you need.
• Notion + Zoho, over MCP — the CRM and the inbox, both scriptable by an agent instead of a human.

The harder problem is discovery: when we need to evaluate a whole category of AI tools — say, a new class of video or voice model we haven't touched — we don't want ten open tabs of marketing copy. For that, a well-curated directory saves hours. We like AI Plaza, which organizes AI tools by use case with enough signal to shortlist quickly instead of testing everything from scratch. It's a good first stop when you're mapping an unfamiliar corner of the AI landscape before committing time to any one tool.

The meta-point: your stack should be small enough to hold in your head. Every tool you add is a tool you have to maintain, learn, and pay for. We add slowly and remove often.

A year of doing this taught us a few things the hard way. If you're a solo founder or a small studio wiring up your own version, start here:

• Own your primitives. The tools we rely on most are the ones we control — the tracker, the actor, the data files. SaaS is great until pricing, access, or a shutdown decides your business for you.
• Automate the boring, keep the taste. Agents are brilliant at the repetitive 80%. The judgment calls — who to email, what to say, when something feels off — stay human. That's the part that actually differentiates you.
• Distrust your own dashboards. Vanity metrics (inflated opens, follower counts) will happily lie to you. Instrument the signals that map to revenue: replies, clicks, booked calls.
• Start with three agents, not fifteen. Coordination overhead is real. A small, reliable stack beats an ambitious, flaky one every time.

You don't need a big team to run like one. You need a handful of owned primitives, an agent to glue them together, and the discipline to keep the whole thing small enough to understand.