A team ships an internal agent to production. Neat little thing. It reads tickets, calls a couple of internal APIs, sends a Slack notification, and marks the ticket resolved. The engineer who deployed it, in the interest of getting something out the door, gave the agent a copy of their own API token. The token has the permissions of a senior engineer, which is to say it can do almost anything.

Most attempts to put AI into design tooling adopt a generate-then-fix flow: the model produces an artifact, and downstream steps try to repair it into something valid. For anything that must be manufactured or coordinated, that is backward. 

Four Tables, One Screen

Picture a support screen for a small online shop. When a customer calls, the agent needs the order's customer, items, prices, and status in one place.

Gemini Enterprise Agent Platform offers various methods for gaining such visibility. Cloud Monitoring is responsible for operational metrics related to the models and agents, Cloud Logging enables you to explore execution details and errors, and Cloud Trace will help you gain further insights into the execution of the agents.

The difference suggests that task length alone is not the main challenge. Long-running work also requires the system to preserve progress, adapt when conditions change, and recover when earlier assumptions no longer hold.

This article walks through the feature engineering techniques that consistently move the needle in real projects, with working Python code (pandas + scikit-learn) and a visual look at where the gains actually come from.

The problem isn't that these tools don't work. It's that adoption is being measured by the wrong thing. Counting how many people have access to an AI chatbot tells you almost nothing about how deeply AI has been woven into the way work gets done. A team of ten people where AI reliably runs one integrated production workflow is arguably further along than a company of a hundred where everyone occasionally pastes text into a chatbot.

This second part covers that second half, the part most vendor announcements leave out.

The company announced Monday that Muse Wonder and Muse Wonder Full are its most capable AI models to date. Built for personal and professional AI agents, the models are designed to handle tasks ranging from software development to document analysis and financial research.

The Chinese AI lab has agreed to lead a seed investment in Winverse AI, a startup developing technology for robots, according to Bloomberg. The round is expected to raise tens of millions of dollars and would value Winverse at approximately $400 million after the investment.

Sometimes you just want a brown bag project. The kind you can start, finish, and ship before your lunch sandwich gets soggy. So I built babbler.

It is easy to read this as a race between AI labs, cloud providers, and security vendors, and to ask which one will win.

Current evaluation guidance explicitly recommends task-specific tests that reflect real-world distributions, production data, continuous evaluation, and calibration against human judgment rather than treating a single numerical score as sufficient.

When teams begin building AI evaluations, it is tempting to reach for an LLM-as-a-judge because it can read almost anything and return a score. That flexibility is useful, but it can also hide a simpler option.

Suppose an agent is asked to process a refund. The final response says, "Your refund has been completed." You could ask another LLM whether that answer sounds correct. A better grader is to check the transaction state in the database or test environment. The database is closer to ground truth than the prose.

The difficult part is not generating a patch. It is ensuring that automated repair changes only code justified by the failure, leaves protected files untouched, and proves that the original failure is actually fixed. Automated program repair research has repeatedly identified patch overfitting as a core risk: a patch can satisfy available tests without being semantically correct. 

You probably think making sense of AI means keeping up with every new tool, agent, and pricing tier. Steve Jobs faced a similar mess at Apple in 1997, with a dozen versions of the Macintosh, and he fixed it with a two-by-two grid on a whiteboard. Almost 30 years later, the “Jobs Matrix for AI” sorts the AI tool market and, more usefully, the AI use cases of Scrum Masters, Product Owners, Agile Coaches, and anyone else in agile product development.

Replace Consumer and Pro with Team and Organization, and Desktop and Portable with Chatbot and Agent, and you get four boxes that show where a use case belongs, what it takes to move it, and which box should stay empty.

AI Inference Metrics

Models process input in units called tokens. Hence, common metrics include time to first token (TTFT), time between tokens (TBT), and time per output token (TPOT). Other measurements could be end-to-end latency, input and output token counts, request rate, error rate, etc.   

• Part 1, Running Sentiment Analysis Inside Neo4j With a Java Plugin, used the VADER lexicon via a pure Java UDF – rule-based, fully local, high throughput.
• Part 2, Wasm Inside Neo4j: Building the Example That Didn't Exist, embedded a Wasm runtime inside a Java UDF using wasmtime-java — sandboxed, still local, lower throughput.

Part 3 takes a different approach. Instead of bundling a scoring model inside the plugin JAR, we call TypeSafe AI's Jev from inside a Java UDF. Jev is a System One model – it doesn't generate text. It takes a state (the text to evaluate) and a set of typed questions and returns structured decisions with explicit probability and confidence information. No prompt engineering, no JSON schema coercion, no parsing.

Recent research is more nuanced, as one 2026 study of real repositories found AI-generated code to be more verbose and to exhibit different duplication patterns, while another maintenance study found lower subsequent maintenance activity for sampled AI-generated files than for comparable human-generated files. A 2025 controlled study likewise found fewer defects in some LLM-generated solutions but also structural problems on harder tasks. The operational conclusion is therefore not that generated code is inherently inferior, but that code volume can grow faster than governance capacity. 

At production scale, the architecture matters. Ingestion, search, indexing, permissions, latency, and updates all need to work independently without slowing down user requests.