Agentic management software is all the hype today: What started with Moltbot and OpenClaw now has a lot of competition: ZeroClaw, Hermes, AutoGPT etc.
These systems work well and allow you to train and build generic agent loops that are genuinely helpful. We run quite a few agents ourselves at Feldera: to review code, to help troubleshoot customer issues, to maintain and debug our infrastructure etc.
Using agents makes me think about an article a famous computer scientist named Mark Weiser once wrote, titled The Computer for the 21st Century. The article starts with:
The most profound technologies are those that disappear. They weave themselves into the fabric of everyday life until they are indistinguishable from it.
- Mark Weiser
In the article Mark envisioned computing that:
- Fades into the background
- Enhances life without constant interaction
- Minimizes demands on attention
- Is calm, reliable, and predictable
Today's agents, the copilots, the chatbots are designed to be human like.
- They have a high desire to explain themselves or summarize
- They generate walls of text
- They require turn-taking discussion
- They mimic human collaboration and ask clarifying questions, may misunderstand or worse assume they understood but do something different
- They need supervision
All of this needs a high cognitive load to interact, parse and manage.
Humans are not a good target for calm technology.
The fix is not smarter prompts. It is software built to meet agents halfway. Ideally that change happens inside existing software, not in a zoo of external agent runners.
Give an agent the right interfaces and it becomes less conversational and more ambient. It no longer needs to constantly ask, explain, summarize, and negotiate. It can stay in the background, react to changes, and make steady progress with less supervision and less noise. That is closer to Weiser’s vision: calm technology, but for machines.
So how do you restructure your software to make that possible?
A few clear agentic design patterns that make agents less noisy, more effective are already well established:
- CLI: a good command-line interface makes it easy for an agent loop to interact with your system and saves tokens.
- Specs: Declarative configs, schemas, manifests. Artifacts that state the desired outcome, not the steps.
- Reconciliation loops (as popularized by Kubernetes): you declare the target state, let the system continuously converge toward it. Detect if something drifts.
Put together, these are useful patterns how existing software can integrate better with agentic loops which leads to less conversation, more convergence. Calm technology for machines.
However, it begs a question: what other "agentic software patterns" exist that are not well known today?
Feldera is a query engine for incremental data processing. It already makes sure to leverage the patterns above: It has a CLI interface. It uses SQL to describe computations declaratively. It orchestrates pipelines through a control plane built around desired-state reconciliation.
Another aspect, especially relevant for agents when working with data -- but rarely discussed -- is how data is presented to them. Most systems expose tables, dashboards, CSV exports etc. Agents then have to poll, diff, and guess what changed by running expensive queries on them.
But, databases can do better: With change data capture (CDC), the system emits a stream of precise updates: inserts, updates, deletes, each tied to specific records. Instead of repeatedly asking "what is the state now?", the agent receives "This changed."
A simple example: consider a fraud-detection agent monitoring transactions. In a snapshot model, the agent must periodically scan a large table of payments to find suspicious activity. Depending on the complexity of the question asked and the data size involved, this can be slow and expensive.
With CDC, the database emits events such as:
- Transaction T123 inserted: $9,800 from account A to B
- Account A flagged as high risk
- Transaction T123 status updated to pending review
... continuously as they happen.
The agent reacts only to these events. It does not need to issue queries that would lead to expensive re-evaluation. It does need to compute diffs. It receives exactly the information that matters, at the moment it matters.
For an incremental engine like Feldera, this model is natural. Queries produce streams of changes, not just static results. The changes are computed incrementally, which makes answering even the most complex questions incredibly cheap.
This is reflected in our agentic demos:
In the video, the agent can do much more than watch fixed rules. It reads news coverage, identifies a new fraud pattern, and updates the pipeline to look for it. The database then does what it is good at: it continuously evaluates that logic over live data and emits changes as suspicious transactions appear. The agent subscribes to that stream and acts. It can flag the transaction, request verification, or notify a human reviewer.
That is the larger point. Agents and CDC streams are powerful together because they split the work well. The agent interprets new information and adapts the logic. The engine applies that logic continuously and emits precise updates when something changes.