Field Notes
Hey, Cal here.
I've been thinking a lot lately about how agents are changing the way I build software. Not in the abstract "AI is going to change everything" way. Very practically. The way I work today is already different from how I worked a year ago. I spend a huge portion of my day with AI systems open. I use them to think through product strategy, review code, generate content, test messaging, audit flows, and pressure-test ideas. Sometimes I'm in a browser, sometimes an IDE, sometimes a CLI, sometimes giving an agent a task and letting it run.
That shift has changed how I think products should be built.
For the last decade, most software was designed around the assumption that a human would sit in front of a screen and click through the product. The core design question was: how do we make this easier for a person to use? That still matters. A lot. But it is no longer enough.
The next design question is: how does this product work when the person is not the only one operating it? What happens when the creator, the founder, the analyst, or the writer has an agent that can call tools, pass structured context, watch long-running jobs, retrieve outputs, revise drafts, and hand finished work back for review?
That is the world I am building for with Niche.
Most software still assumes buttonology. Log in. Click. Fill out. Click next. Review. Generate. Copy. Paste. Export. Upload somewhere else. That has been the dominant shape for years.
In 2026, that model already feels dated. The most capable creators and operators I know are not just looking for another dashboard. They are building workflows. They are asking agents to do real work. They are connecting tools together. They are moving between ChatGPT, Claude Desktop, Cursor, Codex-style environments, internal scripts, APIs, and automations.
That does not mean every creator is suddenly a developer. In fact, one of the biggest changes is that tools like Claude Desktop have made agentic workflows much more approachable for people who are not deeply technical. A creator does not need to live in a terminal to understand the value of saying:
"Research my market, find the strongest story, frame it in my voice, and give me the draft."
The interface can be conversational. The work underneath can be deeply technical. The creator should not have to care whether the work is happening through a UI, an API, an MCP tool call, a background run, or a structured JSON response. They should care about the outcome: did it find something worth saying, did it understand the niche, did it protect the creator's voice, did it produce something credible, did it save time without turning the creator into a generic content machine.
That is the standard.
Niche is a content desk for creators and agents.
At the simplest level, a creator enters a niche. That could be "defense tech analysts," "fitness apps for serious lifters," or "migraine treatment innovation." Niche then scans what is happening around that niche. It looks for live conversations, news, and pre-news signals. It clusters the signal into story candidates. It helps the creator decide what is actually worth talking about. Then it proposes angles, generates platform-native content, creates supporting assets, and brings the whole package back for review.
The basic flow: niche → signal → story → angle → content → review → publish or export.
That sounds simple, but going from a vague niche to a credible content piece in a few minutes is a very different feeling than staring at a blank page. Most creators do not have a shortage of opinions; they have a shortage of structured editorial momentum. They are busy. They are reading things all day. They know their space. They see conversations passing by. But turning that ambient knowledge into consistent, timely, audience-ready content is hard.
Niche compresses that process. It gives creators a way to surface the conversation, take a stance, and produce something that feels connected to what is actually happening right now.
That is only half the idea. The other half is that Niche is built for agents too.
Because the best future products will support both.
Some creators want a clean human interface: open the product, type the niche, pick a story, choose an angle, review the draft, publish. That should feel like an editorial cockpit, not a technical tool.
But there is another kind of creator emerging: the agent-native operator. This person might be a founder, analyst, engineer, writer, consultant, or executive. They may already have agents running in their IDE, personal automations, Claude Desktop with connected tools, or CLI-based workflows. They may not want to click through a traditional SaaS flow at all.
For that person, Niche should not merely be a destination. It should be callable infrastructure. Their agent should be able to ask Niche what stories are emerging in a niche, what the strongest angle is for a specific creator, whether something fits the brand profile, what the creator has already said, then draft for LinkedIn, turn it into a carousel, revise the hook, check source faithfulness, and prepare the publish package.
That is a fundamentally different product posture. The web UI is one surface. The agent interface is another. Both sit on top of the same core engine. That is the architecture I think more products will need. Not "human app first, API later." Not "dashboard with some automation bolted on." One intelligent system with multiple ways to operate it. A creator can drive. An agent can drive. The product should be useful either way.
There is a trap in thinking about agents as simply a faster way to click buttons. That undersells what is happening. An agent does not just speed up the workflow; it changes the shape of the workflow.
A human creator might open Niche and run one session: "Find me a story about defense tech."
An agent can run a richer task:
"Scan defense tech, AI acquisition reform, ISR modernization, and venture-backed dual-use startups. Prioritize stories that reinforce Cal's point of view on decision-support systems. Avoid generic AI hype. Find one angle suitable for a serious LinkedIn post and one suitable for a short video script. Return the source-grounded claims and flag anything speculative."
That is not a faster button click. That is a richer editorial process. The agent can bring more context, compare outputs, ask follow-up questions, revise, inspect the state of the run, use brand context, and decide whether to continue, redirect, or ask the creator for judgment.
And Niche gives that agent a specialized tool suite. A general-purpose AI system can always approximate an answer. It can search the web, summarize articles, suggest angles, draft a post. But approximation is not the same as a purpose-built editorial system. Niche is not trying to replace the agent. Niche is trying to make the agent better. The agent is the operator. Niche is the editorial desk.
I am careful about this because "AI content generator" is not an interesting category to me. Plenty of tools will generate a post; that is not the hard part anymore.
The hard part is knowing what is worth saying. Understanding the niche. Maintaining voice. Not hallucinating a claim because it sounds good. Producing content that compounds a creator's authority instead of just filling a calendar.
That is where Niche is pointed. A good editorial system should be able to tell a creator that a story is fresh but not a great fit for their audience, that an angle is obvious and everyone is going to say it, that a claim is not source-grounded, that something reinforces a recurring thesis worth amplifying, or that something is probably not worth posting. A good editorial system should sometimes say no.
The future of content is not more volume. More volume is easy. The future is better judgment, better timing, better framing, and better fit.
Here is the kind of workflow I want for myself.
I might start with a prompt:
"Use Niche to find one story in defense tech worth publishing today. Prioritize stories that connect to decision support, software-defined warfare, acquisition reform, or dual-use startups. Avoid generic AI hype. I want one LinkedIn post and one short video script. Use my brand profile. Show me the recommended angle before drafting."
An agent should be able to translate that into a structured run:
{
"tool": "niche_signal_scan",
"arguments": {
"niche": "defense tech, acquisition reform, software-defined warfare, dual-use startups",
"brand_id": "cal-default",
"target_platforms": ["linkedin"],
"profile_overrides": {
"framing": {
"allowed": ["analytical", "contrarian", "operator-led"],
"blocked": ["generic AI hype", "hustle content"]
},
"audience": {
"primary": "defense technology executives, GovCon operators, mission software leaders"
}
}
}
}
Then inspect the session:
{
"tool": "niche_session_state",
"arguments": {
"session_id": "sess_abc123",
"wait": 30
}
}
The response should be useful to both the agent and the creator:
{
"session_id": "sess_abc123",
"status": "cp1_awaiting_story",
"phase": "awaiting",
"phase_message": "Ranked three story candidates. Pick one.",
"phase_hint": "Pick a story_id from stories[] and call niche_angle_propose.",
"stories": [
{
"id": "story_2",
"title": "Defense AI is moving from demos to decision infrastructure",
"headline_candidate": "Defense AI is finally moving past demos",
"summary": "Multiple signals point to a shift from experimentation toward operational deployment.",
"recency_score": 0.91,
"relevance_score": 0.88,
"content_potential": 0.89,
"brand_conflict_flags": []
}
],
"next_step": "Pick a story_id from stories[] and call niche_angle_propose."
}
Then ask for angles:
{
"tool": "niche_angle_propose",
"arguments": {
"session_id": "sess_abc123",
"story_id": "story_2"
}
}
And the next niche_session_state poll returns the angles plus a brand-fit recommendation block:
{
"session_id": "sess_abc123",
"status": "cp2_awaiting_angle",
"phase": "drafting",
"picked_story_id": "story_2",
"angles": [
{
"id": "angle_1",
"hook": "The defense AI conversation is finally moving past demos.",
"frame": "analytical",
"tension": "The real shift is not AI replacing human decision-makers. It is AI becoming decision infrastructure for missions too complex to manage manually.",
"cta_direction": "Ask defense software leaders what their decision-support stack actually looks like in 2026.",
"cta_variants": []
}
],
"angle_recommendation": {
"recommended_angle_id": "angle_1",
"reasoning": "Strong fit with Cal's recurring thesis that decision-support systems matter more than generic automation.",
"brand_fit_scores": {"angle_1": 0.92},
"confidence": "heuristic"
},
"next_step": "Pick an angle_id from angles[] and call niche_draft_create."
}
A human can still review every step. But the agent can do the heavy lifting. The creator is no longer manually operating the machine. The creator is directing the editorial system.
One reason agent-native software needs deeper product design is that agents are only as good as the context they can access. If I tell a generic model "Write me a post about defense tech," it can do that, but does it know what I believe? What I have already said? What I refuse to say? That I do not want vague AI hype? The difference between my voice and generic LinkedIn voice? Which claims are too strong? When a story is off-brand?
Usually, no. That is why Niche needs brand context, voice profiles, and editorial memory. A creator's brand is not just a logo and colors. It is what they believe, how they sound, what topics they own, what they avoid, what their audience expects, what they have already published, and what level of evidence they trust. When an agent has access to all of that, the work gets much better. The agent is no longer guessing. It is operating inside a system that understands the creator.
It is easy to take this too far and say: "Great, let the agent publish everything automatically."
I am more cautious than that. For many creators, especially serious professionals, the default should be review. Niche prepares. The creator approves. That is the right trust model.
There will absolutely be creators and operators who want autonomous workflows. They may want a daily scan, a draft waiting every morning, eventually approved agents publishing within specific limits. But that needs auditability. If an agent publishes something on a creator's behalf, the system should know which story it used, which angle it selected, which sources supported the claims, which brand profile was active, what warnings were present, whether the publish was dry-run or committed, which agent or token authorized the action, and whether any trust gates were bypassed.
That is not overengineering. That is the cost of letting machines act in public on behalf of people. Agent-native software needs receipts.
This shift changes how I think about talking about Niche.
For one audience, the message is simple: type your niche, pick the story, post. That is clean, that is human, that is valuable. A creator should be able to understand it in five seconds.
For the AI-native operator, the message is different: give your agents an editorial intelligence layer. Your agent can already write, but can it decide what is worth saying? Can it rank niche-specific signal? Stay inside your brand context? Avoid repeating what you said last week? Prepare a draft with source-grounded claims? Explain why this angle matters now?
Niche is not trying to be another place where you type prompts into a box. Niche is trying to become the system your prompts can call when the task requires editorial judgment.
Content is just the first obvious surface. The deeper idea is that products need to become legible to agents. If software only works when a person manually clicks through it, it will feel increasingly limited.
The products I want to build now need to answer two questions: can a person use this easily, and can an agent use this effectively. Those are not the same question. Humans need clarity, trust, and control. Agents need structure, state, tools, schemas, and predictable contracts. The best products will serve both without collapsing into a mediocre middle. That is hard. That is also the opportunity.
The challenge is not to turn every product into an API. That is too simplistic. The challenge is to identify the actual intelligence layer inside the product and expose it in a way that both humans and agents can use. For Niche, the intelligence layer is signal discovery, story ranking, angle selection, brand fit, voice context, source faithfulness, content generation, revision, rendering, and auditability. The post is the artifact. The editorial system is the product.
That distinction shapes everything: the UI, the API, pricing, onboarding, the roadmap, who the product is for.
The next few years will be strange. Some creators will still want traditional tools, a simple interface, clear buttons, a polished experience. Others will increasingly want headless software, their agents operating tools directly, structured outputs, automations, products they can compose together.
Both groups matter. That is why I am building Niche for both. For the creator who wants a simple workflow, Niche is an editorial cockpit. For the operator working through agents, Niche is headless editorial infrastructure.
For both, the promise is the same: find what matters, take a stance, create something credible, do it faster than starting from scratch, and do it without giving up judgment.
That is the future I am building toward.
Niche was designed as much for agents as it was for creators. Not because agents replace creators. Because the best creators are going to have agents, and those agents are going to need better tools. , Cal
More field notes