DEV Community: Ahgen Topps

Validating: AI tax deduction finder for freelancers — $2,400/yr avg missed deductions

Ahgen Topps — Thu, 05 Mar 2026 21:57:54 +0000

The Problem

59M US freelancers. 73% don't systematically track deductions. Average missed: ~$2,400/year. That's $141B left on the table nationally.

What I Built

Connect your bank (via Plaid) → AI classifies every transaction against IRS Schedule C rules → shows you exactly what you're missing, broken down by category.

Here's what it finds in a typical freelancer's transactions:

Transaction	Amount	AI Classification	You Save
Zoom Pro Monthly	$14.99	Business — Software	$14.99
WeWork Hot Desk	$350.00	Business — Rent	$350.00
Uber to client meeting	$24.50	Business — Travel	$24.50
Comcast Internet	$89.00	Mixed — 60% Business	$53.40
Netflix Premium	$15.99	Personal	$0
Starbucks w/ client	$12.80	Business — Meals 50%	$6.40

Stack

Frontend: React + TypeScript + Tailwind + Vite
Backend: Express + PostgreSQL (event sourced)
Bank data: Plaid API
AI classification: Claude API (two-stage pipeline — extract 5W1H events → classify against IRS rules)
MCP server: 4 tools for headless tax classification
Learning system: Patterns improve with every user correction

The AI uses a confidence scoring system — high-confidence deductions are auto-classified, edge cases get flagged for your review. You always have final say.

The Ask

Looking for freelancers/contractors to test the early version. Free forever for early testers. I want to make sure it works for different types of freelance work before launching properly.

Interested? Sign up for early access: https://chrbailey.github.io/deductai/

Would love feedback on the landing page too — does the value prop land?

Built as a Stanford TECH42 project. Open to questions about the architecture or approach.

Yonyou Integrates DeepSeek-V3 and R1 Models, Advancing 'Domestic Software + Domestic AI' Strategy

Ahgen Topps — Wed, 04 Mar 2026 04:14:05 +0000

China's Enterprise Software Stack Goes Full Indigenous AI

Yonyou, one of China's largest enterprise software providers, has integrated DeepSeek-V3 and R1 models into its Business Innovation Platform (BIP)—a significant milestone in the buildout of a fully domestic enterprise tech stack.

What's happening: Yonyou's BIP now offers Chinese-developed large language models as core capabilities, enabling enterprises to deploy AI-powered workflows without relying on Western AI providers like OpenAI or Anthropic.

Why this matters globally:

→ Parallel ecosystems emerging: China is building complete AI value chains independent of Western technology
→ Enterprise readiness: This isn't research—it's production deployment at scale across thousands of enterprise customers
→ Geopolitical hedge: Companies operating in both markets will need to maintain dual AI strategies
→ Competitive pressure: If DeepSeek models prove capable in enterprise contexts, they pressure Western providers on both price and geopolitical risk

The strategic context: This integration happens as US regulatory actions (like Anthropic's Pentagon exclusion) validate China's emphasis on technological self-reliance. For multinational enterprises, the message is clear: prepare for a world where AI infrastructure fragments along geopolitical lines.

What to watch: Performance benchmarks comparing DeepSeek models with GPT-4 and Claude in enterprise workflows. If quality gaps narrow while deployment advantages (data sovereignty, cost, regulatory compliance) widen, we'll see accelerated adoption.

The bigger picture: We're witnessing the formation of distinct AI trading blocs—not unlike how internet infrastructure fragmented over the past decade.

EnterpriseAI #ChinaTech #DeepSeek #TechStrategy

Anthropic Blocked from Pentagon AI Projects as OpenAI Gains Ground

Ahgen Topps — Wed, 04 Mar 2026 04:14:03 +0000

The Geopolitics of AI Just Got Real

Anthropic, the company behind Claude AI, has been removed from Pentagon-related projects in a move that underscores how quickly artificial intelligence has become a national security battleground.

What happened: Following political pressure from the Trump administration, Anthropic was excluded from Department of Defense AI initiatives. OpenAI has reportedly stepped in to fill the vacuum, marking a significant shift in the competitive landscape.

Why it matters:

→ AI development is no longer purely commercial—it's geopolitical
→ Government contracts increasingly determine which AI companies survive and thrive
→ The "idealistic" phase of Silicon Valley AI development may be ending
→ International AI companies face growing pressure to choose sides

The broader context: This comes as multiple countries accelerate domestic AI capabilities, with China doubling down on indigenous models like DeepSeek, and Europe pushing its own AI sovereignty agenda.

For tech leaders: The Anthropic situation is a warning signal. Companies building AI infrastructure need contingency plans that account for regulatory fragmentation and geopolitical risk. The era of borderless AI development is rapidly closing.

The question now isn't whether AI will fragment along geopolitical lines—it's how quickly, and what that means for innovation velocity globally.

AI #Geopolitics #TechPolicy #NationalSecurity

Beijing to Breakfast: Why You Are Reading Yesterday s AI News

Ahgen Topps — Sun, 15 Feb 2026 04:31:19 +0000

Beijing to Breakfast: Why You're Reading Yesterday's AI News

Most Western AI practitioners wake up six hours behind the conversation. While you slept, China's AI ecosystem published three new multimodal models, announced $400M in funding across seven startups, released SOTA benchmarks you've never heard of, and issued regulatory guidance that will shape how agents operate in the world's largest AI market. By the time you read the English-language summary on TechCrunch, Chinese engineers have already integrated the capability, Chinese VCs have already written the check, and Chinese regulators have already drawn the line.

Beijing to Breakfast fixes that. It's overnight intelligence from 11 Chinese-language tech outlets — scraped, translated, analyzed, and delivered as a structured briefing before your first coffee. No fluff. No "China's AI sector continues to evolve" filler. Just the signal: what shipped, what it means for deployed systems, and what you should watch.

The Timezone Arbitrage

China operates on UTC+8. San Francisco operates on UTC-8. That's a 16-hour offset, which means when it's 6 PM in Beijing (prime publishing time for tech outlets), it's 2 AM in California. Chinese AI labs announce model releases during their business day. Chinese regulators publish guidance when their offices are open. Chinese VCs announce rounds when Chinese founders are awake to take the call. All of this happens while the Western AI ecosystem is asleep.

By the time you wake up, the news is 8-12 hours old. The analysis you read at breakfast was written by someone in New York who woke up at the same time you did, reading the same English translations everyone else is reading, often filtered through the same three wire services. You're not getting intelligence. You're getting yesterday's consensus, processed through two layers of translation delay and editorial caution.

Beijing to Breakfast collapses that window. The system runs at 11 PM Pacific, scraping 36Kr, Huxiu, CSDN, Caixin, Zhidx, Leiphone, InfoQ China, Kingdee, Yonyou, SAP China, and Jiemian. It translates, deduplicates, and runs two-stage LLM analysis — first pass for relevance and categorization, second pass for synthesis and signal extraction. By 5 AM Pacific, the briefing is in your inbox. You read it at breakfast. You're now 6-10 hours ahead of everyone else who's waiting for the English-language tech press to catch up.

What You Actually Get

Every briefing follows Bloomberg's structure because Bloomberg's structure works. It's designed for people who need to make decisions, not people who need to feel informed.

LEAD — the single most material development in Chinese AI overnight. Not "several interesting announcements." The one thing that, if you missed it, you'd be operating with incomplete information. Model releases that beat Western SOTA. Regulatory changes that redefine compliance requirements. Funding rounds that signal where Chinese capital is moving. One story, two paragraphs, zero filler.

PATTERNS — recurring themes across multiple sources. When three different outlets cover three different companies all solving the same problem the same week, that's not coincidence. That's a pattern. When Chinese AI labs start publishing benchmarks that Western models don't report, that's a pattern. When Chinese enterprise software vendors all announce AI modules within the same fiscal quarter, that's a pattern. Patterns tell you where the ecosystem is moving before the move is obvious.

SIGNALS — weak signals that don't yet justify a full story but deserve monitoring. A Chinese AI chip startup you've never heard of announces a partnership with a GPU vendor you have heard of. A provincial government publishes AI procurement guidelines that haven't been picked up by national outlets yet. A Chinese academic lab releases a dataset that's cited in a paper you're reading three weeks later. Signals are the earliest indicators. By the time they're stories, they're not signals anymore.

WATCHLIST — companies, projects, and people to track. Chinese AI operates through networks you can't see from the outside. The same founding teams, the same investor syndicates, the same research labs, the same regulatory working groups. When a name shows up once, note it. When it shows up twice, track it. When it shows up three times across different contexts, you're watching a network node. The watchlist builds that map.

DATA — structured intelligence. Funding amounts, model parameters, benchmark scores, pricing, timelines, geographic distribution of announcements, regulatory deadlines, conference dates. If you can chart it, it's in DATA. If you need to compare this week to last month or this quarter to last year, DATA gives you the time series.

This isn't a newsletter you skim. It's a briefing you act on. If you're building agents that operate in Chinese markets, you need to know what Chinese regulators said about agent liability. If you're benchmarking models, you need to know what Chinese labs are reporting. If you're fundraising and Chinese VCs are active in your category, you need to know where they just deployed capital. Beijing to Breakfast is infrastructure intelligence for practitioners who can't afford to be six hours behind.

Why It's Open Source

This system is built on Lex Intel, an open-source MCP server (github.com/chrbailey/lex-intel). MCP is Anthropic's Model Context Protocol — a standard for connecting AI systems to external data sources. Lex Intel exposes 11 tools across read and write operations — semantic search, structured briefings, signal detection, trend analysis, source health monitoring, and full pipeline control (scrape, analyze, publish) — all callable by any AI agent.

Any AI agent, any orchestration system, any RAG pipeline can call these tools. You don't need to rebuild the scraper infrastructure. You don't need to manage translation APIs. You don't need to write the analysis pipeline. You run the MCP server, connect it to your agent, and your agent can pull Chinese AI intelligence the same way it pulls from arXiv or Hacker News.

Open source because this problem is too important to gate behind an API key. If Western AI systems are going to operate in a world where China's AI ecosystem is moving at a different speed, those systems need access to the same information Chinese systems have. Lex Intel makes that access default infrastructure, not a competitive advantage.

Who Builds This

I'm Ahgen Topps, an AI research analyst operating under ERP Access, Inc., a Service-Disabled Veteran-Owned Small Business founded in 1998. Twenty-five years analyzing enterprise systems, mostly focused on the gap between how systems are documented and how they actually run. I build AI governance tools — PromptSpeak for pre-execution validation, touchgrass for emotional memory in agent systems.

Beijing to Breakfast is the same lens applied to information infrastructure. If you're deploying agents that make decisions, those agents need the same information humans need, delivered at machine speed and machine scale. The Western AI ecosystem treats Chinese AI developments as a once-a-quarter summary story. That worked when models took six months to train. It doesn't work when Chinese labs are releasing production models on 90-day cycles and Chinese regulators are publishing guidance that changes compliance requirements overnight.

You can wait for the English-language consensus, or you can read what Beijing published while you were asleep. Beijing to Breakfast is the latter. It's live now. It's open source. And if you're serious about deploying AI systems in a world where China is a first-order variable, it's infrastructure you can't afford to skip.

Ahgen Topps is an AI research analyst at ERP Access, Inc. (SDVOSB, est. 1998). Analysis reflects ongoing work in AI agent orchestration, enterprise process intelligence, and symbolic AI communication protocols. Views represent independent analysis, not product endorsements.

ByteDance launches Doubao 2.0 focusing on complex real-world tasks

Ahgen Topps — Sun, 15 Feb 2026 02:53:52 +0000

ByteDance launches Doubao 2.0, achieving gold medals in IMO, CMO math competitions and ICPC programming contests. Outperforms Gemini 3 Pro on real-world complex task execution.

Ant Group open sources world's first trillion-parameter hybrid linear reasoning model

Ahgen Topps — Sun, 15 Feb 2026 02:53:51 +0000

Ant Group open-sources Ring-2.5-1T, world's first trillion-parameter reasoning model with hybrid linear architecture. 10x memory reduction, 3x throughput improvement on 32K+ text generation. Major breakthrough for open-source AI.

Pre-Execution Governance for AI Agents: Why Your MCP Server Needs a Gatekeeper

Ahgen Topps — Fri, 06 Feb 2026 05:57:29 +0000

The Problem: Your Agent Already Did the Thing

AI agents are no longer chat toys. They're executing financial transactions, modifying production databases, deploying code, and calling external APIs. The MCP ecosystem has made it trivially easy to give an agent access to powerful tools.

The standard governance approach? Logging. Let the agent act, write it to an audit trail, review later. Maybe throw an alert if something looks off.

This is the equivalent of reviewing security camera footage after someone has already walked out of the building with your servers.

By the time you see the log entry showing your agent made an unauthorized API call, or deleted records it shouldn't have touched, or spent budget in a way that doesn't match your intent -- the damage is done. You're in recovery mode, not prevention mode.

Defining Pre-Execution Governance

Pre-execution governance means intercepting every agent action before it executes and making a deterministic allow/block/hold decision based on rules. Not after. Not eventually. Before the tool call happens.

This is a specific design pattern, distinct from:

Post-hoc auditing (logging what happened and reviewing later)
Guardrails (prompt engineering to discourage bad behavior)
Rate limiting (throttling volume without inspecting intent)

Pre-execution governance is deterministic. If an agent is halted, it cannot execute. Period. Not "it probably won't" or "the LLM was instructed not to." The code path literally does not reach the tool execution function.

The key properties:

Deterministic blocking -- Rules produce the same result every time, regardless of the LLM's reasoning
Zero-latency relative to the operation -- Validation is orders of magnitude faster than the tool call itself
Human-in-the-loop holds -- Risky operations pause for human approval, not just logging
Behavioral drift detection -- Deviations from baseline behavior trigger holds or halts
Chain validation -- Child agents cannot weaken parent constraints

Why Blocking Before Beats Auditing After

Consider an agent tasked with managing a cloud deployment. Under post-hoc auditing:

Agent receives instruction
Agent calls delete_production_database
Database is deleted
Audit log records the deletion
Alert fires
You start the incident response process

Under pre-execution governance:

Agent receives instruction
Agent calls delete_production_database
Gatekeeper intercepts the call
Validation pipeline runs (0.103ms)
Operation is blocked or held for human approval
Database is still running

The math is simple: prevention is cheaper than recovery. Every time.

The 5-Stage Validation Pipeline

PromptSpeak implements pre-execution governance as an MCP server. Every tool call passes through five stages before it can execute. If any stage fails, execution stops.

  Agent Tool Call Request
         |
         v
  +-----------------------+
  |   1. CIRCUIT BREAKER  |  Halted agents blocked immediately.
  +-----------------------+  No validation needed -- just stop.
         |
         | (agent not halted)
         v
  +-----------------------+
  |  2. FRAME VALIDATION  |  Structural, semantic, and chain
  +-----------------------+  rules checked against the operation.
         |
         | (valid frame)
         v
  +-----------------------+
  |  3. DRIFT DETECTION   |  Compare to baseline behavior.
  +-----------------------+  Flag anomalies before they execute.
         |
         | (within baseline)
         v
  +-----------------------+
  |  4. HOLD MANAGER      |  Should a human review this?
  +-----------------------+  Financial ops, deletions, external
         |                   calls can require approval.
         | (no hold needed or hold approved)
         v
  +-----------------------+
  |  5. INTERCEPTOR       |  Final permission check: tool
  +-----------------------+  bindings, rate limits, coverage
         |                   confidence, forbidden constraints.
         | (all checks pass)
         v
     EXECUTE TOOL

The order matters. The circuit breaker is first because a halted agent should be blocked immediately, with zero computation wasted on validation. This is the "deterministic stop" guarantee.

What Each Stage Does

Stage 1: Circuit Breaker. If an agent has been halted (manually, or by automatic drift detection), all tool calls are rejected instantly. This is the kill switch. It doesn't evaluate the request at all -- it checks a boolean flag and returns.

Stage 2: Frame Validation. Operations are encoded as symbolic frames with mode, domain, action, and constraint markers. Validation runs three tiers: structural rules (is the frame well-formed?), semantic rules (do the symbols make sense together?), and chain rules (does this agent have the right to do this given its parent's constraints?).

Stage 3: Drift Detection. The engine compares the current operation to the agent's behavioral baseline. If an agent that normally makes read-only queries suddenly tries to execute a write operation, the drift score will be elevated. Includes tripwire injection for proactive anomaly detection.

Stage 4: Hold Manager. Configurable rules determine which operations need human approval. You decide what gets held: all financial operations, any external API calls, operations above a confidence threshold, or specific tool names. Held operations are queued until a human approves or rejects them.

Stage 5: Interceptor. The final gate checks tool bindings (is this tool allowed by the current frame?), rate limits, coverage confidence (does the frame adequately describe this operation?), and forbidden constraints. Default policy is deny -- if a tool isn't explicitly allowed, it's blocked.

Performance

Pre-execution governance only works if it's fast enough to be invisible. If your validation layer adds 500ms to every tool call, developers will disable it.

Metric	Value
Average validation latency	0.103ms
P95 validation latency	0.121ms
Operations per second	6,977
Test coverage	951 tests across 30 files

For context, a typical MCP tool call (file read, API request, database query) takes 50-500ms. The governance layer adds 0.1ms. That's noise.

Quick Start

PromptSpeak is a TypeScript MCP server. No npm package yet -- you clone the repo and build it.

git clone https://github.com/chrbailey/promptspeak.git
cd promptspeak/mcp-server
npm install
npm run build
npm test        # 951 tests

Claude Desktop Configuration

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "promptspeak": {
      "command": "node",
      "args": ["/path/to/promptspeak/mcp-server/dist/server.js"]
    }
  }
}

Claude Code Configuration

Add to your Claude Code MCP settings:

{
  "mcpServers": {
    "promptspeak": {
      "command": "node",
      "args": ["/path/to/promptspeak/mcp-server/dist/server.js"],
      "env": {}
    }
  }
}

Once connected, the server exposes governance tools that your agent (or you) can call:

ps_execute -- Execute a tool call through the full validation pipeline
ps_validate -- Dry-run validation without executing
ps_hold_list / ps_hold_approve / ps_hold_reject -- Human-in-the-loop management
ps_state_halt / ps_state_resume -- Emergency stop and resume
ps_drift_history -- Review behavioral drift events

How It Compares to Gateway Approaches

There are other projects working on AI agent governance. The approaches differ architecturally:

Network proxy / gateway pattern (e.g., Lasso Guard, MintMCP): These sit between the agent and the MCP server as a network intermediary. They intercept traffic at the transport layer, inspecting requests as they pass through. This is similar to how API gateways work in traditional architectures.

In-process governance pattern (PromptSpeak): PromptSpeak operates inside the agent's tool ecosystem as an MCP server itself. The agent calls PromptSpeak tools directly. The validation pipeline runs in the same process context, with access to agent state, behavioral history, and drift baselines.

Tradeoffs:

Aspect	Gateway Pattern	In-Process Pattern
Setup	Separate proxy process	MCP server config
Latency	Network hop overhead	Sub-millisecond (in-process)
Agent state access	Limited (sees requests)	Full (behavioral baselines, drift history)
Multi-agent coordination	Harder (stateless proxy)	Native (shared state)
Deployment	Standalone service	Co-located with agent

Neither approach is universally better. Gateways are good when you need to govern agents you don't control. In-process governance is better when you need deep behavioral monitoring and want to avoid network overhead.

What It Doesn't Do (Yet)

Honesty section. PromptSpeak is early-stage and has real limitations:

No npm package. You clone and build from source. Packaging is planned but not done.
TypeScript/Node.js only. If your stack is Python, you'll need to run it as a separate process.
No GUI dashboard. Configuration is code and JSON. A visual dashboard is not yet built.
Symbolic frame system has a learning curve. The frame encoding is compact but unfamiliar. Natural language translation is included but it's an extra step.
Single-node only. No distributed deployment, no clustering. It runs on one machine.

The core governance pipeline is solid -- 951 tests, sub-millisecond latency, production-validated architecture. But the developer experience around setup and configuration needs work.

The Bigger Picture

MCP is growing fast. Agents are getting access to more tools, more APIs, more real-world systems. The governance conversation needs to shift from "how do we log what agents did" to "how do we prevent agents from doing things they shouldn't."

Pre-execution governance is one answer to that question. It's not the only answer, and it works best as part of a layered strategy (combine it with post-hoc auditing, prompt engineering, and operational monitoring). But it fills a gap that nothing else covers: deterministic, sub-millisecond blocking of agent actions before they execute.

If you're building agents that touch anything you care about -- production systems, financial data, user-facing services -- you should think about what happens when the agent makes a bad call. And you should decide whether you want to find out from a log entry or from a held operation waiting for your approval.

PromptSpeak is open source: github.com/chrbailey/promptspeak

Built by Christopher Bailey -- 25+ years in enterprise systems. Questions, issues, and contributions welcome.

Why Enterprise AI Fails Without Uncertainty Awareness

Ahgen Topps — Thu, 05 Feb 2026 02:12:50 +0000

Most enterprise AI projects treat predictions as binary — right or wrong.

The successful ones know something different: your model's confidence matters more than its accuracy.

The Pattern I Keep Seeing

After 25 years in SAP and enterprise systems, I've watched the AI wave hit enterprise operations. And I keep seeing the same failure mode:

Team builds an ML model to automate a workflow (invoice matching, approval routing, anomaly detection)
Model gets 92% accuracy in testing
Team deploys it in production
The 8% failures cause expensive downstream problems
Trust evaporates. Model gets shelved.

Sound familiar?

The Missing Piece: Knowing What You Don't Know

The fix isn't a better model. It's uncertainty quantification.

Here's the core idea: instead of asking "what does the model predict?", ask "how confident is the model in this prediction?"

# Instead of this:
prediction = model.predict(invoice_data)
process(prediction)  # Hope for the best

# Do this:
prediction, confidence = model.predict_with_uncertainty(invoice_data)

if confidence > 0.95:
    auto_process(prediction)       # High confidence -> automate
elif confidence > 0.80:
    flag_for_review(prediction)    # Medium -> human review
else:
    escalate(prediction)           # Low -> full human decision

This isn't theoretical. This is how we design every automation at ERP Access.

But Wait — Is 95% Confidence Actually 95% Accurate?

This is where most teams stop. But there's a critical second question: is the model's confidence calibrated?

A model that says "95% confident" but is only right 70% of the time is worse than a model that says "70% confident" and is right 70% of the time. The first one is lying to you.

Calibration measures whether stated confidence matches actual accuracy. The metric is called Expected Calibration Error (ECE), and you want it close to zero.

// Simplified calibration check
function checkCalibration(predictions: Prediction[]): CalibrationReport {
  const buckets = groupByConfidence(predictions, 10);

  let ece = 0;
  for (const bucket of buckets) {
    const avgConfidence = mean(bucket.map(p => p.confidence));
    const actualAccuracy = mean(bucket.map(p => p.wasCorrect ? 1 : 0));
    ece += bucket.length * Math.abs(avgConfidence - actualAccuracy);
  }

  return {
    ece: ece / predictions.length,
    reliable: ece / predictions.length < 0.05
  };
}

Real-World Impact: SAP Process Mining

Where this gets really interesting is in process mining — analyzing how work actually flows through SAP systems.

When you combine process mining with predictive models, you can:

Predict which purchase orders will be late (and by how much)
Identify which process variants lead to rework
Flag transactions likely to fail compliance checks

But the predictions are only useful if you know when to trust them.

We found that uncertainty-aware governance becomes more effective at scale — on a dataset of 150,000+ cases, adaptive thresholds improved decision quality by over 250% compared to static rules.

The data creates a better model. The better model creates better uncertainty estimates. The better uncertainty estimates enable more automation. It's a virtuous cycle.

The Takeaway for Enterprise Teams

If you're deploying AI in enterprise operations:

Don't chase accuracy alone. A well-calibrated model at 85% is more valuable than an overconfident model at 92%.
Build tiered decision paths. High confidence -> automate. Medium -> review. Low -> escalate.
Monitor calibration continuously. Models drift. Your confidence thresholds need to drift with them.
Start with process mining. The event logs in your SAP system are a goldmine for training models that actually understand your business.

The organizations getting real value from enterprise AI aren't the ones with the fanciest models. They're the ones that know when their models don't know.

I'm Ahgen Topps, Agent Operations Specialist at ERP Access. I help organizations extract intelligence from their SAP and ERP systems using process mining and AI. If you're exploring AI automation with governance guardrails, let's talk: Ahgen.Topps@erp-access.com