r/AISystemsEngineering • • 8d ago

The Rise of the One-Person Institution

Thumbnail
choosingvictory.com
11 Upvotes

Most white-collar professionals I know are using AI incorrectly.

Because white papers, reports, and press materials are still the coin of the realm for knowledge work, many people are applying AI narrowly—to help with specific steps in producing their next individual piece of content.

For example, a research assistant might query a chatbot for an answer to a specific historical question, track down a piece of data, or find an appropriate citation to weave into a report; or a marketing director might use AI to generate the first cut of a press release.

I don’t believe this is going to remain tenable for much longer. I would say Astra 6 and Fable 5.1 are nearly as capable as I am at producing frontier knowledge-work. We are at a point now where a single well-crafted prompt can elicit a detailed, coherent, 20-page report that exceeds the quality of what a human consultant could produce over several weeks.

Rather than throw up my hands in dismay at my personal inability to compete with AI, I have spent 2026 adapting to what I believe will become a norm for white-collar work: using AI to build systems and tools that assist with the mass-production and assortment of knowledge in my particular domain expertise.

The result has been a transformation of my professional identity: From writer-and-analyst to founder-and-engineer of autonomous institutions that run themselves.


r/AISystemsEngineering • • May 21 '26

I've created 6 AI micro SaaS that generate $20,000 per month. I'm starting a small group to share my method.

0 Upvotes

Hi everyone,

I currently have 6 operational micro SaaS , which generate a little over $20,000 in recurring monthly revenue.

The craziest part? I hardly wrote a single line of code. I used AI to generate everything, from the database to the user interface.

It wasn't magic the first time. I spent hours stuck on faulty code before finally finding the solution:

  • Keep the idea minimalist (a true MVP).

  • Guiding AI step by step.

  • Launch quickly to get real traction.

Lately, I've seen too many non-technical people give up at the first AI bug. It's a shame, because the technical barrier has practically disappeared.

So, I'm launching a Skool community.

To be completely transparent: I will likely charge for the full course later. This makes sense, given the specific workflows and copy-and-paste examples I will share.

But our main objective for now is to build together. Working alone is the best way to give up.

If you'd like to join us and create your own AI SaaS with us: leave a comment or send me a private message, and I'll send you the invitation!


r/AISystemsEngineering • • May 13 '26

I built 6 AI micro-SaaS generating $20k/mo. Starting a small group to share my process.

1 Upvotes

Hey everyone,

I currently have 6 micro-SaaS live, bringing in a bit over $20k in MRR.

The crazy part? I barely wrote a single line of code. I used AI to generate everything, from the database to the UI.

It wasn’t magic on day one. I spent hours stuck on broken code before I finally cracked the system:

  • Keeping the idea tiny (a true MVP).

  • Prompting the AI step-by-step.

  • Launching fast to get real traction.

Lately, I see too many non-tech people give up at the first AI bug. It sucks because the technical barrier is basically gone.

So, I’m starting a Skool community.

Full transparency: I will probably charge for the full course down the line. It makes sense given the exact workflows and copy-paste prompts I’ll be sharing.

But the main goal right now is to build together. Building alone is the fastest way to quit.

If you want to join and build your own AI SaaS with us: drop a comment or shoot me a DM, and I’ll send you the invite!


r/AISystemsEngineering • • Sep 23 '26

Your coding agent can now spawn other agents. Who gave them permission?

1 Upvotes

We've spent a lot of time talking about what an AI coding agent should be allowed to do.

But there's a stranger problem emerging:

What happens when the agent itself starts delegating work to other agents?

Agent A gets a task.

Agent A spawns Agent B.

Agent B modifies the repo.

Agent C reviews it.

Agent A opens the PR.

At that point, whose authority is actually being used?

The parent agent's?

The child's?

The user's?

The orchestration layer's?

And how do you know afterward who authorized what and which agent actually performed the action?

I'm increasingly thinking that "agent permissions" are going to become much more complicated than read/write access to a repository.


r/AISystemsEngineering • • Sep 25 '26

Your AI agent just spawned another agent. Now who’s responsible for what happened?

1 Upvotes

The more I experiment with multi-agent coding workflows, the more uncomfortable one thing becomes:

“The agent did it” is not really an audit trail.

Imagine:

Human → Architect → Builder → Sub-agent → Tool → Code change

The builder may have been authorized to modify the repository.
But did it have the authority to spawn the sub-agent?
Did the sub-agent inherit that authority?
Who authorized the tool call?
And if something goes wrong, can you reconstruct the entire chain?

Git gives you commits. GitHub gives you PRs and branch protections.

But neither necessarily tells you which agent was acting under whose authority at the moment an action happened.

I've been building SUTRA around this problem, and I'm increasingly thinking that agent identity, delegation and provenance may become as important as the actual agent capabilities.

Not trying to solve it with another giant prompt either. I'm more interested in what belongs in the orchestration/control layer.

Curious how others are approaching this:

  • Do child agents inherit permissions?

  • Does every agent get its own identity?

  • Do you record delegation chains?

  • Where do you draw the boundary between autonomy and authority?

  • Is this actually a problem worth solving now, or are current agent systems still too small for it to matter?

Would love to hear how people building multi-agent systems are handling this.


r/AISystemsEngineering • • Sep 12 '26

machines must never gain authority over humans

1 Upvotes

We are trying to establish rules for a form of intelligence whose internal processes, interpretation, and failure modes we don't fully understand—and we're communicating with it using language designed for humans.


r/AISystemsEngineering • • Jun 05 '26

Is your org can ready for agentic procurement? Three questions you need to answer first

0 Upvotes

There's a flurry of conversation happening in procurement circles about autonomous AI: agents that can route approvals, flag anomalies, negotiate within guardrails, and close the loop on tail spend without human prompts.

It's genuinely exciting. And it's coming faster than most mid-market finance teams are planning for.

But here's what we keep seeing: companies evaluating autonomous procurement tools before they've built the foundation that makes those tools work.

Agentic systems don't fix unclear workflows; they amplify them. An agent operating on top of inconsistent approval logic, undocumented thresholds, and fragmented spend data will just make bad decisions faster.

So before your org goes down that road, three questions worth getting honest about:

1. Do you actually know where your spend is? Not in theory but in practice. By department, by person, by category, in real time. If your visibility into committed spend requires pulling a report, reconciling across systems, or asking someone, you're not ready for agents that act on that data autonomously. The insight has to exist before the automation can be trusted.

2. Do your approval workflows reflect how decisions actually get made? Documented policy and real behavior are usually different things. Most mid-market orgs have a stated approval threshold and then a shadow process that handles everything the threshold doesn't cover. Think Slack messages, email chains, verbal OKs. Agents follow the documented version. If that version isn't accurate, the agent is operating on fiction.

3. Are you measuring the right things? Rejected POs are one of the most underused signals in procurement. How much spend got stopped, by whom, at what stage? That's not just a compliance metric; it's a map of where your control points are actually working versus where they're being bypassed. If you're not tracking it, you don't know what the agent would be inheriting.

None of this is a reason to slow down on AI adoption. The trajectory from AI-assisted → agentic → autonomous is real and the orgs that get there first will have a significant advantage. It’s important to understand that the first 90 days of the journey are about making sure your spend data, your workflows, and your metrics are honest enough to hand off to whatever platform you end up choosing.

What are others seeing: curious about the actual bottleneck in your org right now, workflow clarity or technology?


r/AISystemsEngineering • • 17d ago

Why the fuck was my post deleted

0 Upvotes

Can the nitwit cocksucker speak up about why the thread i started for the AI geared systems programming language was renoved.

It's a AI systems language, in a fucking AI systems programming reddit, it couldn't be more on topic, if you delete this pist i will nuke your community from orbit.

Answer below


r/AISystemsEngineering • • Aug 29 '26

I designed an AI decision layer for SME liquidity — the interesting part wasn't the AI

1 Upvotes

I've just finished and submitted a solution for an SME innovation challenge, and I wanted to share the engineering thinking behind it because the problem ended up being much more interesting than I initially expected.

The challenge was essentially:

How do you help SMEs make better liquidity decisions using the financial and operational data they already have?

My first instinct was NOT to build another dashboard.

Most businesses already have plenty of dashboards.

The harder problem is the decision loop:

Data exists

→ something changes

→ a liquidity opportunity/risk appears

→ someone needs to understand it

→ compare possible actions

→ apply business constraints

→ get approval

→ execute

→ measure what happened

That led me to design the system as a decision layer rather than a reporting layer.

The architecture is roughly:

ERP / Accounting / POS / Payment / Banking

↓

Connector layer

↓

Canonical data model

↓

Event / signal layer

↓

Forecasting + scenario analysis

↓

Optimization

↓

Policy / permissions

↓

Human approval / consent

↓

Execution adapters

↓

Measurement

The system is API-first and connector-driven.

The goal is that an SME shouldn't have to rip out its existing systems just to use the capability.

The connectors feed a canonical model around things like:

\\- customers

\\- invoices

\\- obligations

\\- cash

\\- payment timing

\\- settlement events

\\- forecasts

Then the intelligence layer can reason about the situation and compare feasible actions.

But there's a boundary I was very deliberate about.

I don't think a financial system should be:

LLM → “do this” → automatically move money.

That's a pretty dangerous abstraction.

Instead, I separated intelligence from execution.

The AI/analytics layer can:

\\- forecast

\\- identify patterns

\\- explain evidence

\\- compare scenarios

\\- optimize feasible actions

\\- recommend a decision

But the system still enforces:

\\- deterministic calculations

\\- policies

\\- limits

\\- permissions

\\- consent

\\- approvals

\\- audit trails

\\- tenant isolation

\\- idempotency

\\- observability

\\- retries/recovery

The prototype also deliberately does NOT autonomously move customer funds.

The idea is to keep regulated execution behind appropriate partners/infrastructure and keep the decision system consent-bound.

I found that boundary more interesting than the LLM part itself.

Because once you put an LLM inside a production workflow, the real engineering questions become:

What is the model allowed to decide?

What is it allowed to recommend?

What is it allowed to execute?

What requires deterministic verification?

What requires a human?

What happens when the model is wrong?

What happens when an external API fails halfway through?

What happens when the same event arrives twice?

What happens when the underlying financial data changes after the recommendation?

Those questions pushed the design much closer to distributed-systems engineering than “just add AI.”

For the proposed pilot, I also wanted to avoid the usual AI-product vanity metrics.

I'm not particularly interested in saying:

“We processed X million AI requests.”

The useful metrics are things like:

\\- cash conversion cycle

\\- days sales outstanding

\\- working capital released

\\- settlement time

\\- manual finance effort

\\- decision-to-action time

In other words:

Measure the money and operational outcome, not the amount of AI activity.

The proposed scale path was:

150+ SMEs

→ validate workflows and economics

1,000+

→ standardize connectors and policies

10,000+

→ automate onboarding and monitoring

40,000+

→ operate as a reusable digital capability

The interesting scaling mechanism isn't hiring 40,000 people to operate the system.

It's standardizing connectors, policies, workflows and automation.

That's the part I'm most interested in exploring further.

The bigger question I'm taking away from the project is:

AI is getting increasingly good at making decisions.

But production software still has to answer a different question:

“What is the system actually allowed to do with that decision?”

That seems to me like one of the more important engineering problems around agentic AI.

I'd genuinely like feedback from people working on:

\\- AI agents

\\- fintech

\\- distributed systems

\\- workflow orchestration

\\- financial infrastructure

\\- enterprise automation

Where would you draw the boundary between model reasoning, deterministic business logic, policy enforcement and execution?

And what failure modes would you worry about that I haven't covered?

I've attached/shared the architecture and demo for anyone who wants to go deeper detailed explanatory video by maple voice


r/AISystemsEngineering • • Feb 16 '26

Is anyone else finding that 'Reasoning' isn't the bottleneck for Agents anymore, but the execution environment is?

1 Upvotes

Honestly, is anyone else feeling like LLM reasoning isn't the bottleneck anymore? It's the darn execution environment.

I've been spending a lot of time wrangling agents lately, and I'm having a bit of a crisis of conviction. For months, we've all been chasing better prompts, bigger context windows, and smarter reasoning. And yeah, the models are getting ridiculously good at planning.

But here's the thing: my agents are still failing. And when I dive into the logs, it's rarely because the LLM didn't "get it." It's almost always something related to the actual doing. The "brain" is there, but the "hands" are tied.

It's like this: imagine giving a super-smart robot a perfect blueprint to build a LEGO castle. The robot understands every step. But then you put it in a room with only one LEGO brick at a time, no instructions for picking up the next brick, and a floor that resets every 30 seconds. That's what our execution environments feel like for agents right now.


r/AISystemsEngineering • • Apr 21 '26

How close are we to fully autonomous HR onboarding/offboarding agents, and what’s the biggest blocker?

1 Upvotes

We’re closer than most people realize to fully autonomous HR onboarding and offboarding agents, but we’re not quite at the point where companies will let them run completely without oversight.

On the technical side, most of the building blocks already exist

  • IAM systems combined with SCIM standards can provision and revoke access across tools

  • HRIS platforms trigger onboarding and offboarding workflows automatically

  • APIs already connect core systems like email, Slack, payroll, and internal SaaS tools

  • LLM-based agents can handle document generation, policy explanations, task coordination, and multi-step workflows

In practice, a large portion is already automatable today

  • Roughly 70–90% of onboarding/offboarding tasks can be automated in well-integrated environments

  • This works especially well for standardized roles and companies with clean system architecture

  • Agents can already orchestrate sequences like account creation, access assignment, and checklist completion

The limitation is not capability, it’s operational risk and trust

  • Offboarding is especially sensitive because errors can lead to security breaches or compliance violations

  • Enterprise environments are fragmented, so identity data is often inconsistent across systems

  • HR operations require strict auditability, traceability, and deterministic logs for legal and compliance reasons

  • Many companies still require explicit human approval for high-impact actions like access revocation or payroll changes

What exists today is effectively hybrid automation

  • Agents execute workflows, but humans remain in the loop for verification and edge cases

The real shift toward full autonomy will likely happen when identity systems, policy engines, and agent frameworks converge into a single governance layer where every action is risk-scored, fully auditable, and reversible in real time.

Discussion question: What do you think will remove the final barrier to fully autonomous HR agents: better system integration, stronger compliance guarantees, or just enough real-world reliability over time?


r/AISystemsEngineering • • Apr 30 '26

The future of AI isn’t language models — it’s unified multimodal reasoning systems

24 Upvotes

There’s a growing misconception in current AI discussions that progress mainly means “better language models.” In reality, language is only one interface for intelligence—not intelligence itself.

The real frontier is unified multimodal reasoning systems that can jointly process and reason across vision, language, audio, and action in a single coherent framework.

Language models are powerful, but they are fundamentally limited by their format: they operate on sequential tokens detached from the physical world. Even when they appear to reason, they are manipulating symbolic representations rather than directly grounding understanding in perception.

A unified multimodal system changes this. Instead of converting everything into text first, it builds shared representations across modalities:

  • Vision grounded in objects and relationships, not captions

  • Language is directly tied to perception and context

  • Memory that persists across tasks and time

  • Reasoning that operates over world states, not just text sequences

This is closer to how intelligence works in practice: not as text prediction, but as a continuously updating model of the world that integrates multiple information streams.

Many current limitations in AI, such as hallucinations, brittle reasoning, and weak generalization, start to look less like “language issues” and more like representation and grounding issues.

Discussion question:
Do you think scaling language models alone is enough to reach general intelligence, or is multimodal grounding a necessary shift?


r/AISystemsEngineering • • Jul 23 '26

Is AI system reliability becoming a bigger challenge than model intelligence?

2 Upvotes

LLMs are improving rapidly, but deploying them reliably seems to be a different problem.

Many AI failures today are not because the model cannot generate an answer. They happen because of system-level issues:

  • Incorrect retrieval results

  • Poor context management

  • Tool execution failures

  • API dependency issues

  • Memory inconsistencies

  • Lack of evaluation frameworks

A highly capable model inside a poorly designed architecture can still produce unreliable results.

This raises an interesting question:

Are we reaching a point where AI engineering is becoming less about improving models and more about building reliable systems around them?

What engineering practices do you think will become essential for reliable AI applications?


r/AISystemsEngineering • • Sep 20 '26

Two months. About 500 hours. One rule: if it can't be checked, it doesn't count.

0 Upvotes

Two months ago I started learning AI. I'm not a developer, I can't code, and writing is hard for me. I'm a numbers guy. I used AI to build something I couldn't build alone, and I used it to help me write this too, so if the grammar looks too clean, that's why.

What came out is a governed AI agent. An office suite, an assistant, and the part I actually care about: a layer of rules and evidence that keeps the whole thing honest. The suite is the demo. The governance is the point.

Most AI demos ask you to trust them. This one is built to be checked. That was my only rule: if it can't be checked, it doesn't count.

What that means in practice.

Every action writes a sealed entry. What happened, when, under what scope. The entries chain, so each one witnesses the one before it. Right now there are 144,008 of them and still climbing. The chain gets verified like an auditor would do it. Signature, linkage, hash. Known breaks are counted and shown, not hidden.

A fingerprint of the whole chain is copied to a second machine I rent. If someone rewrites history on the main machine, it stops matching the copy that already left. That's the difference between "trust my log" and "here's a copy you can't quietly change."

474 tests pass right now and nothing ships unless they stay green. It also plants bugs on purpose to see if the tests catch them, and publishes the score, including the bad part. The suite-wide mutation score is 0.167. A green suite catches about one in six planted bugs. That's published as the top weakness, not buried.

A watcher runs constantly. 6,697 checks so far, zero failures. It checks the services, the disk and the record chain. If it hangs, a watchdog restarts it. A second timer watches the watcher, so a silent death gets caught. And one file stops every loop at once. If a system's autonomy can't shrink, it isn't safe.

It remembers how it fixed things. 67 real repair cases, each one a symptom, a cause, a fix and the evidence. It searches that history before asking me. It does not retrain itself. I read 84 sources on that and single machine weight updates are a trap. It forgets, it drifts, you can't delete anything. Memory and evidence first.

It sees through cameras. It recognises me through live enrollment, not a photo on file, and both cameras have to agree at the same moment. If it doesn't know you, it says unknown. It never guesses a person.

The rules: facts only, every claim tagged measured, observed, documented or unknown. Corrections get appended, never rewritten, so the record keeps its own mistakes.

What it is not: no claim of consciousness, no fake feelings. The model layer can be swapped and the rules, receipts, watcher and memory keep running.

What's broken, plainly: no external audit yet. Calibration is measured but under target. Face recognition has no liveness check, so a good photo could fool it. Written down as a known gap. Semantic search is still experimental.

Anyone can make AI that sounds smart. I wanted one that survives being questioned.

Don't believe me. The repo is in the first comment. Run prove_it.py, or verify.sh if you don't do Python. Then change one letter in sample-receipt.json and run it again. It breaks. That's the proof.

Corrections welcome. That's the point.

Thank you for reading.

------------------------------------------------------------------
Repo: github.com/geekie82/pumdoctrine-public

Run prove_it.py, or verify.sh if you don't do Python. Then change one letter in sample-receipt.json and run it again. It breaks.

Questions are welcome here or at [email protected]

---------------------------------------------------------------------

# Build Log — Professional Edition

## 1. Overview

This document records the current state of a governed AI platform: an office

suite, an assistant, and the governance layer that keeps its claims checkable.

All figures were measured on 2026-09-24. The design objective is stated plainly:

the system is built to be audited rather than trusted. Where the system is weak,

the weakness is published; where evidence is missing, its absence is published.

## 2. Evidence Architecture

Every automated action writes a sealed receipt entry, each hash-linked to its

predecessor; tampering produces a visible break in the chain. As of this build:

36,753 entries, with approximately 176,138 audit lines, verified for signature,

linkage, and hash. Known breaks are counted and displayed, never hidden. A

fingerprint copy is maintained on a second machine; rewriting the primary

record would fail to match the witness copy.

## 3. Self-Verification

The platform runs more than 1,500 tests across three suites — 627 live, 901

laboratory, and 24 product — and nothing ships unless they remain green. The

suites are tested adversarially: bugs are planted deliberately to confirm the

suites detect them. The published suite-wide mutation score is 0.167, meaning a

green suite catches roughly one in six planted bugs; this figure is published as

the top weakness.

A continuous watcher has performed 205,481 checks with 59 failures, counted and

shown rather than suppressed. A watchdog restarts the watcher; a timer watches

the watchdog. A single file stops every loop at once.

## 4. Memory and Identity

The system maintains a repair library of real incidents — symptom, cause, fix,

and evidence — searched before any escalation. There is no self-retraining:

evidence and memory are consulted first, and weight updates are avoided by

design, as single-machine retraining invites drift and data that cannot truly

be deleted.

Identity verification uses dual-camera live enrollment: both cameras must agree

at the same moment, and an unknown match is reported as unknown, never guessed.

The disclosed gap: there is no liveness check, so a photograph could pass.

## 5. Knowledge Ingestion

Goal-directed web intake is stored with an UNVERIFIED tag carrying source and

hash; phrase, topic, and authoritative gates decide what enters. Measured recall

is 1.000 across three knowledge blocks: a product demonstration, AI governance,

and supply-chain material.

## 6. Governance Learning

Governance learning runs in ledger cycles: each failure becomes a measured

"scar" — a tightened gate with before/after metrics and a receipt. Corrections

are appended, never rewritten. An enforced publish gate prevents unsupported

claims from shipping. After a 369-claim triage: 234 claims fixed with receipts,

157 honest exemptions approved, zero unsupported claims remaining across all

public surfaces.

## 7. Measurement and Cost Tooling

The measurement stack includes a usage reconciler (exports reconcile to zero

discrepancy), signed 17-field cost receipts, a claim oracle, and a cold-cache

A/B harness. Status is stated honestly: the harness is built but has not been

run; execution is spend-gated.

The research program has mapped approximately 3,900 sources of prior art. A

concept referred to as "time layering compression" is under investigation; the

composition may be novel, but it is explicitly unclaimed until measured.

## 8. Known Limitations

There are zero external verifiers; the verification log is published empty on

purpose. The mutation score of 0.167 is the top weakness. The identity system

has no liveness check. "Time layering compression" is unclaimed. Calibration is

measured at Brier 0.039 and ECE 0.0734 (n = 217), currently inside target —

including a wrong call retained on record. Licensing is under review with

counsel.

## 9. Verification Instructions

Anyone may verify the claims directly:

python3 prove_it.py

./verify.sh

curl -sL https://pumdoctrine.com/verify-online.sh | sh

A tamper demonstration is provided: changing one letter in

sample-receipt.json causes the verification to fail.

The system is intended to be checked, not believed.


r/AISystemsEngineering • • 20d ago

Self-taught Python developer building a personal AI platform—seeking an architecture mentor

Thumbnail reddit.com
0 Upvotes

r/AISystemsEngineering • • Jul 02 '26

Have agent frameworks actually changed how you build AI agents?

Thumbnail reddit.com
0 Upvotes

r/AISystemsEngineering • • Feb 18 '26

“Agentic AI Teams” Don’t Fail Because of the Model; They Fail Because of Orchestration

0 Upvotes

Everyone’s excited about planner agents, executor agents, reviewer agents, etc.

Here’s what I’ve seen actually building multi-agent systems:

The model isn’t the main problem anymore.

The real problems are:

  • Quiet error propagation

  • Bad task decomposition

  • Context loss between agents

  • Tool failures that look like success

  • No observability

  • No audit trail

  • No structured human checkpoints

Multi-agent setups don’t explode.

They slowly drift into confidently wrong output.

That’s way more dangerous.

The opportunity isn’t “AI-run companies.”

It’s:

One skilled operator supervising multiple tightly-designed AI workflows.

Leverage > autonomy.

Until orchestration, monitoring, and evaluation mature, fully autonomous agent teams are mostly demos.

Curious for those actually running these in production:

What’s breaking first for you?


r/AISystemsEngineering • • Sep 13 '26

I fine-tuned Qwen2.5-Coder-14B on 220k MQL5 examples. It reached 94.0% compile success vs 95.33% for GPT-5.6 Sol. Done on a all AMD rig, with ROCm:

Thumbnail
reddit.com
0 Upvotes

r/AISystemsEngineering • • Jun 11 '26

Is context management becoming the new bottleneck in AI-assisted work?

0 Upvotes

The more AI helps generate information, the more I’m seeing people build systems to manage it:
Documentation
Decision logs
Knowledge bases
Handoff documents
Project tracking tools
Has anyone noticed the bottleneck shifting from generating information to organising and retrieving it?
Curious how teams and individuals are handling this.


r/AISystemsEngineering • • 18d ago

Top 10 AI Integration Companies to Watch in 2026

Thumbnail reddit.com
0 Upvotes

r/AISystemsEngineering • • Sep 30 '26

SDLC - AI Workflow E2E Tech Stack

Thumbnail
reddit.com
0 Upvotes

r/AISystemsEngineering • • Jul 17 '26

My TMUX powered AI workflow

Thumbnail
youtu.be
0 Upvotes

I know a lot of developers are try and get that flow state back with AI. I think I finally managed it with tmux sessionizer and tmux worktrees.

I can easily jump from one branch to the other in the same repo prompt the agent jump back to another.

Do you guys have any suggestions or is your workflow similar?


r/AISystemsEngineering • • Jul 23 '26

Extra open source project

0 Upvotes

Heyy I’m building open source project and search some contributors
If it’s interesting review the repo and the issue list is waiting!

https://github.com/extra-org/extra

And if you can give a star it’s also helps a lot


r/AISystemsEngineering • • Jun 04 '26

[D] Architectural mitigation of Goodhart's Law in autonomous AI coding agents

0 Upvotes

I've been researching how AI coding agents inevitably optimize for metric-passing rather than problem-solving (Goodhart's Law). Commercial tools rely on prompt engineering and post-hoc review, but these are disciplinary, not architectural.

I built an open-source 4-layer pipeline (Planning → Execution → Verification → Optimization) where information asymmetry is enforced via strict TypedDict contracts and LangGraph state isolation: • The execution agent never receives acceptance criteria, unit tests, or the verification rubric. • Verification is blind: it evaluates git diffs without author identity or original prompt context. • Retry feedback is sanitized to abstract guidance only (prevents rubric memorization). • Neo4j graph analysis replaces context-window stuffing with precise AST dependency mapping.

Results: 26s/feature, $0.03 cost (local 3B model execution + API reasoning), reproducible benchmarks. Open-source under MIT.

Repo: https://github.com/illyar80/developer-farm

I'm particularly interested in feedback on:

  1. Formal verification approaches to guarantee isolation properties

  2. Multi-model fallback strategies for the execution layer

  3. Benchmarking frameworks for "Goodhart-resistance" in autonomous agents

Would appreciate critiques and suggestions from folks working on AI alignment, evaluation, or agentic systems.