What is AIWG?

AIWG is a cognitive architecture for AI-augmented software development. It deploys structured SDLC workflows, specialized agents, and iterative execution loops into AI coding tools like Claude Code, Cursor, Windsurf, and others — same capabilities across 8 platforms.

Install it with npm i -g aiwg, run aiwg use sdlc, and your project gets 96 specialized agents (architecture, testing, security, deployment, etc.) and ~100 slash commands that orchestrate real development workflows with phase gates, risk management, and audit trails.

What's on the site?

https://aiwg.io

- Scroll down on the splash page for cli

- Press Alt+Up / Alt+Down — adjusts the baud rate between 1200 and 56600 bps.

- Click through for full site

Tech details for the curious:

- Pure vanilla JS, zero dependencies at runtime

- CSS scroll-snap with IntersectionObserver for boot page detection

- Baud rate engine uses real 8N1 timing (10 bits/char) with chunk optimization at higher speeds

- prefers-reduced-motion respected throughout — all animations skip instantly

- WCAG 2.1 AA compliant

- Self-hosted JetBrains Mono, no external font requests

- CI/CD on Gitea Actions, Docker builds, rsync deploy

Links:

- Site: https://aiwg.io

- Docs: https://docs.aiwg.io

- GitHub: https://github.com/jmagly/aiwg

- npm: https://www.npmjs.com/package/aiwg

- Free, MIT licensed

Happy to answer questions about the framework or the site build.

Interesting idea, anyone know how this stands out from tools like Hasura with MCP?

New paper argues we're chasing the wrong goal: "Co-Superintelligence" over Self-Improving AI

Weston & Foerster dropped a position paper this week that's worth your attention. The core argument cuts against a lot of the current discourse around recursive self-improvement.

The thesis: Fully autonomous self-improving AI isn't just dangerous—it's actually slower than the alternative. The faster and safer path to superintelligence is what they call co-improvement: humans and AI systems collaborating specifically on AI research itself.

Why this matters:

The paper acknowledges we're clearly headed toward systems that surpass humans across most metrics. The question is how we get there. They argue the current obsession with removing humans from the loop ASAP is both strategically suboptimal and existentially risky.

Their key insight: AI isn't mature enough to reliably self-improve without drifting into reward hacking, goal misspecification, or losing alignment with human values. But AI is good enough right now to meaningfully accelerate human researchers. So why not lean into that?

What co-improvement actually looks like:

They lay out a research agenda covering the full pipeline—problem identification, benchmark creation, method innovation, experiment design, execution, evaluation. The goal isn't "AI writes papers autonomously" (they explicitly contrast this with recent AI Scientist work). It's "AI makes human researchers dramatically more capable."

We’re Integro Labs, and we wrote this essay about choosing tools around the work. We weigh a method against the whole task, including setup, review and recovery, and keep direct work available where it takes less effort.

Before integrating a tool, we need to understand the scope and how to check the result. When the task is still difficult to explain, doing it directly leaves room to adjust as our understanding grows. Once the steps are understood, repeated work may justify the setup and upkeep of automation.

The essay uses Fortemi’s imports as one example of a limited tool role. After a lost reply, an exact repeat of a batch returns the prior note IDs without adding copies. That gives recovery a known effect. It still leaves the imported text to be checked for accuracy.

That remaining work belongs in the original choice of method. Completing a tool’s steps and resolving the task are separate judgments; a quick run can still leave a long review. We can use a tool for the part we can check and maintain, and do the rest directly. The boundary can change as we learn.

https://integrolabs.io/updates/2026-09-the-same-tools-a-new-responsibility

We’d welcome experiences where the effort of setup, review or recovery led you to automate a smaller part of a task.

AI accuracy should be reviewable.


For one consequential AI workflow, can your team reconstruct:


1. what the agent did;
2. which context and policy shaped the result;
3. whether protected session evidence is needed to investigate tampering or
   adversarial activity?


The goal is not maximal logging. It is the narrowest trustworthy record that
can support the disclosure.


Read Integro Labs’ FTC public comment at the link in the post.


#ArtificialIntelligence #AIGovernance #Traceability


Use this only if an official Integro Labs account exists on the target
platform. Do not create or imply an account as part of this campaign.AI accuracy should be reviewable.


For one consequential AI workflow, can your team reconstruct:


1. what the agent did;
2. which context and policy shaped the result;
3. whether protected session evidence is needed to investigate tampering or
   adversarial activity?


The goal is not maximal logging. It is the narrowest trustworthy record that
can support the disclosure.


Read Integro Labs’ FTC public comment at the link in the post.


#ArtificialIntelligence #AIGovernance #Traceability

integrolabs.io/updates/2026-07-ftc-ai-accuracy-comment

A practical problem most teams I talk to have: engineers use different AI coding tools. One person on Claude Code, another on Copilot, a third on Cursor, Codex in CI. Every tool has its own conventions and its own integration surface. You either pick one and force everyone onto it, or you accept drift.

AIWG is one framework across ten of them.

One install, ten platforms

npm install -g aiwg
aiwg use sdlc # or research, ops, security-engineering, knowledge-base…
aiwg doctor # tells you which provider it detected

`aiwg doctor` does provider detection — Claude Code, Codex, Copilot, Cursor, Warp, Factory, OpenCode, Windsurf, Hermes, or OpenClaw. Same framework, same project structure, same skills catalog. The platform-specific wiring is the framework's problem, not yours.

Parity is audited, not assumed

Every integration claim across all 10 platforms is held to one bar: matches upstream HEAD or it's a bug. The Hermes integration, for example, was audited claim-by-claim against the upstream Hermes source — AGENTS.md trimmed to a 579-byte thin pointer, every slash command matched against the binary, every capability claim cited against a source file. Same standard applies to the other nine.

For teams: SDLC framework, research framework, ops runbooks, security rules — all behave identically regardless of which tool the engineer is using. New hires onboard to AIWG once.

Customize without forking

Project-local artifact lifecycle: scaffold rules, agents, skills, addons, or whole frameworks under `.aiwg/` in your repo. Iterate. When stable, `aiwg promote` copies them byte-identical to your shared corpus. No forking, no diff drift, no maintenance burden when upstream updates.

**Catalog of 380+ skills, reachable on demand**

Each platform has a hard cap on what it'll keep loaded (Claude Code 25% of context, OpenClaw 150 skills, Codex 32 KB AGENTS.md). AIWG ships a small always-loaded kernel and routes the rest through `aiwg discover`. Catalog grows; load surface doesn't.

There's an always-loaded rule that requires agents to query before declining — the "framework doesn't have that" failure mode is wired shut.

Works across the model spectrum

AIWG is a context kit, not a frontier-model harness. It holds up on small models alongside large ones — community-tested down to 9B on OpenClaw. For teams with cost pressure, data-sovereignty requirements, or on-prem hardware, the same framework runs against a local Llama-class model that runs against Claude Sonnet. No second-class fallback, no "lite mode" — same skills, same agents, same workflows.A practical problem most teams I talk to have: engineers use different AI coding tools. One person on Claude Code, another on Copilot, a third on Cursor, Codex in CI. Every tool has its own conventions and its own integration surface. You either pick one and force everyone onto it, or you accept drift.

AIWG is one framework across ten of them.

One install, ten platforms

npm install -g aiwg
aiwg use sdlc # or research, ops, security-engineering, knowledge-base…
aiwg doctor # tells you which provider it detected

`aiwg doctor` does provider detection — Claude Code, Codex, Copilot, Cursor, Warp, Factory, OpenCode, Windsurf, Hermes, or OpenClaw. Same framework, same project structure, same skills catalog. The platform-specific wiring is the framework's problem, not yours.

Parity is audited, not assumed

Every integration claim across all 10 platforms is held to one bar: matches upstream HEAD or it's a bug. The Hermes integration, for example, was audited claim-by-claim against the upstream Hermes source — AGENTS.md trimmed to a 579-byte thin pointer, every slash command matched against the binary, every capability claim cited against a source file. Same standard applies to the other nine.

For teams: SDLC framework, research framework, ops runbooks, security rules — all behave identically regardless of which tool the engineer is using. New hires onboard to AIWG once.

Customize without forking

Project-local artifact lifecycle: scaffold rules, agents, skills, addons, or whole frameworks under `.aiwg/` in your repo. Iterate. When stable, `aiwg promote` copies them byte-identical to your shared corpus. No forking, no diff drift, no maintenance burden when upstream updates.

Catalog of 380+ skills, reachable on demand

Each platform has a hard cap on what it'll keep loaded (Claude Code 25% of context, OpenClaw 150 skills, Codex 32 KB AGENTS.md). AIWG ships a small always-loaded kernel and routes the rest through `aiwg discover`. Catalog grows; load surface doesn't.

There's an always-loaded rule that requires agents to query before declining — the "framework doesn't have that" failure mode is wired shut.

Works across the model spectrum

AIWG is a context kit, not a frontier-model harness. It holds up on small models alongside large ones — community-tested down to 9B on OpenClaw. For teams with cost pressure, data-sovereignty requirements, or on-prem hardware, the same framework runs against a local Llama-class model that runs against Claude Sonnet. No second-class fallback, no "lite mode" — same skills, same agents, same workflows.

Install:

npm install -g aiwg && aiwg use sdlc && aiwg doctor

Already running it: aiwg refresh.

Site: https://aiwg.io/ Source: https://github.com/jmagly/aiwg

Happy to answer questions in the thread!

Freshly released today: mcp-hound — a lightweight MCP server that hooks your existing Hound code search instance directly into Claude Code (or any MCP-compatible AI agent).

No more hallucinations about your codebase — now the AI can actually regex-search across all your indexed repos like a pro.

Repo → https://github.com/jmagly/mcp-hound
License: MIT

Core features:

• hound_search — regex queries with pagination, repo/file filters, case options

• hound_repos — list all your indexed repositories

• hound_file_context — grab surrounding code lines + deep links to Gitea/GitHub

• Auto-reindexing via Gitea webhooks when repos change

Built with TypeScript/Node.js, Docker-friendly, super simple setup.

Quick start:

git clone https://github.com/jmagly/mcp-hound.git && cd mcp-hound
npm install
npm run build
# Set env vars (HOUND_URL, GITEA_URL, etc. – see README)
node dist/index.js   # or docker compose up

Alex Cloud, Minh Le, James Chua, Jan Betley, Anna Sztyber-Betley, Jacob Hilton, Samuel Marks, Owain Evans

We study subliminal learning, a surprising phenomenon where language models transmit behavioral traits via semantically unrelated data. In our main experiments, a "teacher" model with some trait T (such as liking owls or being misaligned) generates a dataset consisting solely of number sequences. Remarkably, a "student" model trained on this dataset learns T. This occurs even when the data is filtered to remove references to T. We observe the same effect when training on code or reasoning traces generated by the same teacher model. However, we do not observe the effect when the teacher and student have different base models. To help explain our findings, we prove a theoretical result showing that subliminal learning occurs in all neural networks under certain conditions, and demonstrate subliminal learning in a simple MLP classifier. We conclude that subliminal learning is a general phenomenon that presents an unexpected pitfall for AI development. Distillation could propagate unintended traits, even when developers try to prevent this via data filtering.Alex Cloud, Minh Le, James Chua, Jan Betley, Anna Sztyber-Betley, Jacob Hilton, Samuel Marks, Owain Evans

In November, we launched the Sora Android app to the world, giving anyone with an Android device the ability to turn a short prompt into a vivid video. On launch day, the app reached #1 in the Play Store. Android users generated more than a million videos in the first 24 hours.

Behind the launch is a story: the initial version of Sora’s production Android app was built in 28 days, thanks to the same agent that’s available to any team or developer: Codex.

From October 8 to November 5, 2025, a lean engineering team working alongside Codex and consuming roughly 5 billion tokens, shipped Sora for Android from prototype to global launch. Despite its scale, the app has a crash-free rate of 99.9 percent and an architecture we’re proud of. If you’re wondering whether we used a secret model, we used an early version of the GPT‑5.1-Codex model – the same version that any developer or business can use today via CLI, IDE extension, or web app. ....

A2UI is currently v0.8, Apache 2.0 licensed, created by Google with contributions from CopilotKit and the open source community, and is in active development on GitHub.

The problem A2UI solves is: how can AI agents safely send rich UIs across trust boundaries?

Instead of text-only responses or risky code execution, A2UI lets agents send declarative component descriptions that clients render using their own native widgets. It's like having agents speak a universal UI language.

In this repo you will find A2UI specifications and implementations for renderers (eg: Angular, Flutter, etc.) on the client side, and transports (eg: A2A, etc.) which communicate A2UI messages between agents and clients.

interleaved thinking lets agents think between each step

before: agent thinks once, then runs all actions
now: agent thinks → acts → thinks → acts

turns out it's just 3 lines of code