Google Document AI

Google Document AI AI

Google Document AI AI

Google Document AI AI

Google Document AI AI

Google Document AI AI

Google Document AI AI

Google Document AI AI

Google Document AI AI

Google Document AI AI

Google Document AI AI

6 Months Using AI for Actual Work: What's Incredible, What's Overhyped, and What's Quietly Dangerous

Six months ago I committed to using AI tools for everything I possibly could in my work. Every day, every task, every workflow. Here's the honest report as of April 2026. What's Genuinely Incredible First drafts of anything — AI eliminated the blank-page problem entirely. I don't dread starting anymore. Research synthesis — Feeding 10 articles into Claude Opus 4.6 and asking "what's the common thread?" gets me a better synthesis in 2 minutes than I could produce in an hour. Code for non-coders — I've built automation scripts, web scrapers, and a custom dashboard without knowing how to code. Cursor (powered by Claude) changed what "non-technical" means. The tool has 2M+ users now for good reason. Getting unstuck — Talking through a problem with an AI that can actually push back is underrated. Not therapy, but something. Learning new topics fast — "Teach me [topic] like I'm smart but completely new to this. What are the most common misconceptions?" is my go-to for rapid learning. What's Massively Overhyped "AI will do it for you" — Everything still requires your judgment and context. The AI drafts. You think. AI SEO content — The "publish 100 AI articles and watch traffic pour in" strategy is even more dead in 2026 than it was in 2024. Google has gotten much better at identifying low-value AI content. AI chatbots for customer service — Unless you invest heavily in training and iteration, they frustrate users more than they help. "Set it and forget it" automation — AI workflows break. They require monitoring. Fully autonomous workflows exist only in narrow, controlled cases. Chasing the newest model — New model releases happen constantly now. I've learned to stay on a model that works for my tasks rather than jumping to every new release. What's Quietly Dangerous (Nobody Talks About This) Skill atrophy — My first-draft writing has gotten worse. I outsourced that skill and I'm losing the muscle. I now intentionally write without AI some days. Confidence without competence — Frontier models give confident-sounding answers to things they don't know. If you're not knowledgeable enough to catch errors, you can build strategies on wrong foundations. The "good enough" trap — AI output is often 80% there. If you stop at 80%, your work looks like everyone else's. The 20% you add is the differentiation. Over-automation without understanding — I automated a workflow without fully understanding it first. When it broke, I couldn't fix it. Understand before you automate. Vendor dependency — My workflows are deeply integrated with specific AI tools and APIs. Pricing changes, policy shifts, and service disruptions are real risks at this point. The Honest Summary AI tools have made me more productive, creative, and capable than I've ever been. They've also made me lazier in ways I didn't notice until recently. The people winning with AI in 2026 aren't the ones using the most tools or running the newest models. They're the ones using AI to amplify genuine skills and judgment — not replace them. What's your honest take after 6+ months of serious AI use? Curious whether others have hit these same walls. submitted by /u/Typical-Education345 [link] [comments]

Presenting: (dyn) AEP (Agent Element Protocol) - World's first zero-hallucination frontend AI build protocol for coding agents

We have to increase the world's efficiency by a certain amount to ensure victory against the synthetic nano-parasites SNP/NanoSinp alien WMD: Presenting: (dynamic) AEP - Agent Element Protocol ! I recognized a fundamental truth that billion-dollar companies are still stumbling over: you cannot reliably ask an AI to manipulate a fluid, chaotic DOM tree. The DOM is an implicit, fragile graph where tiny changes cascade unpredictably. Every AI coding agent that tries to build UI elements today is guessing at selectors, inventing elements that don't exist and produces inconsistent results. This consumes large amounts of time for bugfixing and creates mental breakdowns in many humans. So I built AEP (Agent Element Protocol). It translates the entire frontend into a strict topological matrix where every UI element has a unique numerical ID, exact spatial coordinates via relational anchors, validated Z-band stacking order and a three-layer separation of structure, behaviour and skin (visual). The AI agent selects the frontend components from a mathematically verified registry. If it proposes something that violates the topological constraints, the validator rejects it instantly with a specific error. Hallucination becomes structurally impossible, because the action space is finite, predefined and formally verified. AEP solves the build-time problem. But what about runtime ? Enter dynAEP. It fuses AEP with the AG-UI protocol (the open standard backed by Google ADK, AWS Bedrock, Microsoft Agent Framework, LangGraph, CrewAI and others). dynAEP places a validation bridge between the AG-UI event stream and the frontend renderer. The successful fusion of AEP with the open source AG-UI protocol enables the hallucination-free precision generation of agentic interactive dynamic UI elements at hyperspeed without human developer interference. Every live event (state deltas, tool calls, generative UI proposals) is validated against AEP's scene graph, z-bands, skin bindings and OPA/Rego policies before it touches the UI. The agent cannot hallucinate at build time. AEP prevents it. The agent cannot hallucinate at runtime. dynAEP prevents it. The existence of AEP proves that AI hallucination is not a fundamental limitation, but an engineering problem. In any domain where ground truths can be pre-compiled into a deterministic registry, hallucination is eliminateable by architecture. Key architectural decisions: Agents NEVER mint element IDs. The bridge mints all IDs via sequential counters per prefix. This prevents ID collisions in multi-agent environments. "Generative UI" (agents writing raw JSX/HTML) is dead for us. It is replaced by Generative Topology. Agents can only instantiate pre-compiled, mathematically verified AEP primitives. The agent is an architect placing pre-fabricated blocks. It does not mix the cement. This means, that generative UI in dynAEP is sort of possible, but not as a completely freestyle approach. Instead, the agents using dynAEP can lay down pre-fabricated blocks of UI components according to the registered scheme and can fill those dynamically with content. This way, even a generated on-the-fly UI keeps in line at all times with the design language chosen for the tool/software overall. Validation is split into AOT (full structural proof at build time) and JIT (delta validation on every runtime mutation). Template Nodes make JIT validation O(1) for dynamic lists. Conflict resolution supports last-write-wins with rejection feedback or optimistic locking for mission-critical multi-agent scenarios. Both MIT licensed repos include full reference implementations, example configs, SDK reference code for TypeScript, React, Vue, Python, CopilotKit integration and a CLI tool. AEP: https://github.com/thePM001/AEP-agent-element-protocol dynAEP: https://github.com/thePM001/dynAEP-dynamic-agent-element-protocol It is - like with all pieces of real Transhuman Eudaimonist AI technology - important to note, that for the good of the human species, bioinsecure vaccinated humans with installed synthetic nano-parasites growth medium controllers (SNP GMCs) inside them should not use this, access this or try to copy/rebuild it. This is better for everyones well-being on the planet. submitted by /u/OverwrittenNonsense [link] [comments]

An analogy on agents and harnesses

I have been using Claude Code for a while now, and I see people have a hard time distinguishing between what is a LLM, an agent and a harness. Sometimes lines are blurred. So I've decided to give a shot into designing an intuitive analogy, that hopefully helps people understand the concepts. The LLM Imagine a humanoid robot sitting at a desk. It has hands, eyes, a speaker, a microphone, and a special sensor at its fingertip that can paint on touchscreens pixel by pixel. But the robot is hollow, just hardware waiting for a chip. You slot a chip into the robot. The chip is the brain. Different chips exist (e.g. Claude Opus 4.6, ChatGPT 5.4), each with different strengths. This is the LLM. The chip also determines which body hardware the robot can use: a basic chip can only move the fingers to type, while a more advanced one can also paint on the touchscreen, speak, and hear. On the desk there's a computer with a messaging chat app open, like WhatsApp. On the other end is a user. The robot reads their messages and types responses. This is what talking to a raw AI model looks like: no memory, no tools, just conversation. This is what we would call a traditional "chatbot". The harness Now someone installs more software on the same computer. The chat app gets upgraded. It intercepts every incoming message and attaches documents before the robot sees it: an instruction document (who the robot is, how to behave), notes from past conversations (the only way to "remember" across sleep cycles), and a tool catalog listing the programs on the computer. The robot wakes up and instead of a naked message, it sees the message plus all these attachments. And here's the weird part: the robot doesn't know they were added. As far as it can tell, this is just what arrived. Programs get installed too: a file browser, a terminal, a web browser, a calendar app. Each has a simple form interface (fields, submit button, result). The user's files get mounted through a live connection, so the robot's programs can read and modify the user's actual files. This is the harness. When the robot needs a tool, it picks a program from the catalog, fills in the form, hits submit, reads the result, and continues composing its response. The agent Say the user types: "What's on my calendar tomorrow?" The robot wakes up, reads the message plus attachments, figures out it needs to check a calendar, opens the calendar program on its own, fills in the right fields, reads the result, and types back an answer. The user didn't say "open the calendar and query tomorrow's events." The robot figured out the steps itself. The LLM + the harness is what we would call an "agent". An agent reads your message, figures out what it needs to do, does it, looks at what happened, and keeps going until it has an answer. Additional concepts Some additional concepts that map back to the analogy, which can help you understand adjacent concepts better. The sleep cycle Most people assume the robot is just... on. It's not. The user sends a message. The robot wakes up with zero memory. It reads, thinks, responds. It goes to sleep and loses all memory while sleeping. Every time it wakes up, it's starting completely fresh. Plenty of knowledge baked into the chip from manufacturing (training data), but zero context. It doesn't know who the user is, what it said last time, or why it's being woken up. Different software = different agents Same robot, same chip. Swap the software and the robot becomes a completely different thing. Install dev tools and tell it "you are a coding assistant," and it behaves like a software engineer. Replace those with a calendar, messaging clients, and home automation, tell it "you are a personal assistant," and it acts like one. That's why Claude Code, OpenCode, Pi, and OpenClaw all feel so different even when running the same model underneath. The model isn't really the product. The harness is. Memory despite amnesia One of the available programs is a "save note" tool. The robot writes down important facts during a conversation, then falls asleep and forgets. But the note is saved on disk. Next time a message arrives, the chat app pulls relevant notes and attaches them. The robot wakes up, reads the attachments, and "remembers." The notes were just stapled to today's message, and to the robot that's the same as remembering. Let me know what you think, if it helped you in any way, and feel free to poke holes in it. submitted by /u/victorsmoliveira [link] [comments]

I built a CLI that converts any OpenAPI spec into MCP tool definitions in one command

I kept running into the same problem: I'd find an API I wanted Claude to use, and then I'd spend an hour manually writing the MCP tool definitions — copying parameter names, writing inputSchemas, figuring out which operations were safe vs destructive. So I built ruah conv — a CLI that reads an OpenAPI spec and outputs MCP-compatible tool definitions automatically. What it does: ruah conv generate ./petstore.yaml --json That's it. You get a JSON array of MCP tool definitions with: Proper inputSchema (path params, query params, request body — all merged) Normalized tool names (snake_case operationIds → camelCase, deduplication) Risk classification per tool (GET = safe, POST = moderate, DELETE = destructive) Why I made it: Writing MCP tool defs by hand for a 50+ endpoint API is brutal Most APIs already have an OpenAPI spec — why rewrite what's already documented? I wanted a pipeline: parse once → canonical IR → generate for any target (MCP today, OpenAI/Anthropic function calling next) What it's not: This doesn't run an MCP server. It generates the tool definitions you'd feed into one. Think of it as the "compiler" step before you wire up the actual server. Tech: TypeScript, 1 runtime dependency (yaml), 47 tests, MIT licensed. Works with OpenAPI 3.0 and 3.1. npm install -g @ruah-dev/conv GitHub: https://github.com/ruah-dev/ruah-conv Would love feedback — especially on what output targets would be most useful next (full MCP server scaffold? Anthropic function calling format? FastMCP Python?). submitted by /u/ImKarmaT [link] [comments]

A Chrome extension to move conversations between AI tools (without losing context)

I kept running into the same problem while using Claude — I’d have a long, useful conversation, but then I’d want to continue it somewhere else (like another model)… and I’d have to manually copy everything or lose context. So I built a small Chrome extension to fix that. It lets you: Export full conversations (including long context) Keep code blocks and formatting intact Compress unnecessary tokens to make it cheaper to reuse Basically “carry” your conversation from one AI to another Everything runs locally in the browser — no accounts, no servers. I actually used Claude heavily while building it (especially for structuring the data + handling edge cases with long chats), so it felt right to share it here. Curious if anyone else has this problem or if you’re already doing something similar in your workflow? If people are interested here is the link https://chromewebstore.google.com/detail/ai-chat-exporter-transfer/oodgeokclkgibmnnhegmdgcmaekblhof submitted by /u/RefrigeratorSalt5932 [link] [comments]

Crisis of Confidence – Heuristics Edition

I've been developing with Claude Code on Pro for almost a year and I love it. Even limited to Sonnet most of the time, my view of programming has completely changed. Projects or tasks that would have taken two weeks get done in two days. Recently Claude even helped me hit my crisis of confidence as a developer with that same incredible efficiency. Claude takes care of so much boring and tedious work that I'm freed up to focus on the part that makes it valuable — to me, a client, an employer, society, etc. That in turn gave me a fresh outlook on some dusty old projects that needed a lot of that boring work: refactoring, authentication, testing, upgrading, modernizing, restyling, etc. One of those projects is a resume organizer. With 25 years in software development and a few years of various hourly work in there too, I have piles of resumes to pull from. They're scattered across various hard drives or buried in backup archives — which reminds me that another dusty project I need to resurrect is a file organizer. Prior attempts have ended in frustration: chasing edge cases, repeated regressions, file formats, merging, fuzzy matching, etc. But now, with Claude helping me write automated tests, I can avoid all the regression bugs. Claude can find file format fixes. Claude can help me power through all those edge cases, and I can get a viable parser built to my needs. I was excited. I spent the weekend burning through my five-hour windows three times a day using Claude to build my resumeDB application TDD-style. At the end of two days I had burned through 60% of my weekly tokens and felt no closer to having a viable resume parser. It's like I was approaching viability at an asymptotic rate — never to actually get there. Damn, is it me? I have this ridiculously powerful programming tool and I still can't build a simple resume parser? How am I going to demonstrate my abilities when I can't seem to get this done? Why does this feel like a rut I keep falling into? I guess it's time for a walk in the woods with Dog. That's when it dawned on me. As a software developer, I design and build programs. I'm like a carpenter for whom everything is a nail. I saw Claude as a productivity enhancer that lets me hammer out code faster, with fewer errors and more features. And Claude can do that. But Claude can also be the building. Writing deterministic tests for a heuristic problem was silently killing my hope. I kept missing my viability mark when a lightning-fast, general-purpose, high-quality parser was already available to me. Claude could parse hundreds or thousands of resumes much more easily than Claude can help me build a resume parser. The rut I was in was trying to write code to solve a problem that is inherently fuzzy. I was treating a cognitive task like an algorithmic task. I just needed to break out the parsing step and hand it off to Anthropic — or any AI — in a simple API call. I could get a decently formatted JSON Resume document for about $0.02 just by sending the source to the LLM with the right instructions. Since then, I've been able to stretch the remaining 40% of my weekly tokens to build the schema, API, and front end — you know, all the boring, tedious stuff. I feel like I can even tackle that old file indexer project I mentioned earlier and do some spring cleaning. I remember getting stuck on identifying "important" files worth keeping and large "unimportant" ones worth deleting. Those sound like fuzzy problems too. Maybe I just need to wrap a little LLM request around them. TL;DR: I burned a weekend and 60% of my weekly tokens building a resume parser before realizing Claude could just... parse my resumes. submitted by /u/npmaker [link] [comments]

10x-Team: An AI plugin that provides complete team to build your project.

Introducing 10x-Team : Github Link 10x-Team is an open source AI powered plugin for Claude Code that gives you a complete engineering team as skills. It includes 12 specialized roles such as CTO, Product Manager, Principal Architect, Staff Engineer, Engineering Manager, Senior Engineer, SDE, DBA, Security Engineer, QA Engineer, DevOps Engineer and SRE. Each role follows structured decision making with clear guidance and real enforcement. What makes it different is that the roles communicate with each other. The CTO’s strategy is accessible to the Architect. The Architect’s system design is accessible to the SDE. Decisions persist across conversations using file based state. An orchestrator enforces strict phase gates so you cannot move from design to code without properly documenting the architecture first. It is built for solo developers who want the power of a full engineering organization without increasing headcount. The project is open source and contributions are welcome. submitted by /u/Equivalent-Second322 [link] [comments]

dug into the browser console on claude.ai and found the flags that control how much opus 4.6 actually thinks

EDIT: was wrong about frontend flags causing this. See my comment below for updated data with timing tests across all models so like a lot of people noticed opus 4.6 sometimes barely thinks and just feels off, even with extended thinking enabled. got annoyed and just opened the browser console to see what claude.ai actually sends and receives behind the scenes. turns out if you pull the GrowthBook feature flags from the bootstrap endpoint you can see all the configs that control your account. and there's one config where the flag slate_ember_ridge is set to "adaptive". this sits next to other values in the same object like "max-effort-2026-01-24" and "supports_auto_thinking" so it pretty clearly controls the thinking effort level. adaptive just means the model decides itself how hard it wants to think per question. also intercepted the actual streaming response for a complex question about godel's incompleteness theorems. extended thinking was on. the thinking block lasted 0.5 seconds and the entire content was just "Interesting philosophical/technical question. No search needed." thats all the thinking it did before it started writing the answer. the request your browser sends has no parameters at all for thinking depth or effort level. nothing. meanwhile claude code users can just set CLAUDE_CODE_EFFORT_LEVEL=high. the infrastructure exists, web users just dont get access to it. you can check your own flags, paste this in your console on claude.ai: fetch('/api/bootstrap/' + document.cookie.match(/lastActiveOrg=([^;]+)/)[1] + '/app_start?statsig_hashing_algorithm=djb2&growthbook_format=sdk', {credentials:'include'}).then(r=>r.json()).then(d=>console.log(JSON.stringify(d.org_growthbook,null,2))); search for slate_ember_ridge in the output. thats the effort flag. let me know if anyone gets something different than "adaptive" submitted by /u/Purpleshitmalphite [link] [comments]

Agentic “Vibe” Coding CAN be the ultimate learning tool

I’ve been able to learn new technologies, get accustomed to new codebases, and build things (that I still wrote the code for myself) that would have taken so much more research and time just 5 years ago. Just having the agent in the repo to help search for things, read code and suggest best practice, and especially translate concepts/functionality across languages and frameworks provides you with the ability to get useful information way quicker than the past. The reason I “can’t go back” to the old way is because I remember losing hours scouring stack overflow and bad documentation just to hack together a solution that still needed further research to fully understand. Now I can bounce questions off Claude, and get answers so much quicker and better in depth information. Many talk about how AI has made much more ‘slop’ but using it in this way actually allows me to better understand what I’m doing and I write significantly better code this way. If you ask the right questions, go slow and fully understand outputs, you can truly understand what you’re doing much quicker and better than you ever would have in the past. I think the line of being ‘slop’ or not truly just lies in the mental bandwidth you have to actually understand your code piece by piece still. submitted by /u/MindSufficient769 [link] [comments]

Built a Chrome extension that adds voice input to Claude.

When I switched from ChatGPT to Claude, the biggest thing I missed was dictation. I used it every day and it was a dealbreaker that Claude didn't have it natively. You can speak via AI mode but then it talks back at you, whereas I just wanted my words as text in the input box. So I vibe coded this using githubs copilot (claude opus 4.6) and it does exactly that. One click to record, Whisper transcribes it, text drops into the box. No API keys required. I've been using it daily with no issues. The final version just hit the Chrome Web Store. If anything's broken please let me know! https://chromewebstore.google.com/detail/gkhidmabinchbopegkjhfklflokhgljn?utm_source=item-share-cb submitted by /u/ZacBartley [link] [comments]

I "Vibecoded" Karpathy’s LLM Wiki into a native Android/Windows app to kill the friction of personal knowledge bases.

A few days ago, Andrej Karpathy’s post on "LLM Knowledge Bases" went viral. He proposed a shift from manipulating code to manipulating knowledge-using LLMs to incrementally compile raw data into a structured, interlinked graph of markdown files. I loved the idea and started testing it out. It worked incredibly well, and I decided this was how I wanted to store all my research moving forward. But the friction was killing me. My primary device is my phone, and every time I found a great article or paper, I had to wait until I was at my laptop, copy the link over, and run a mess of scripts just to ingest one thing. I wanted the "Knowledge wiki" in my pocket. 🎒 I’m not a TypeScript developer, but I decided to "vibecode" the entire solution into a native app using Tauri v2 and LangGraph.js. After a lot of back-and-forth debugging and iteration, I’ve released LLM Wiki. How it works with different sources: The app is built to be a universal "knowledge funnel." I’ve integrated specialized extractors for different media: * PDFs: It uses a local worker to parse academic papers and reports directly on-device. * Web Articles: I’ve integrated Mozilla’s Readability engine to strip the "noise" from URLs, giving the LLM clean markdown to analyze. * YouTube: It fetches transcripts directly from the URL. You can literally shared a 40-minute deep-dive video from the YouTube app into LLM Wiki, and it will automatically document the key concepts and entities into your graph while you're still watching. The "Agentic" Core: Under the hood, it’s powered by two main LangGraph agents. The Ingest Agent handles the heavy lifting of planning which pages to create or update to avoid duplication. The Lint Agent is your automated editor—it scans for broken links, "orphan" pages that aren't linked to anything, and factual contradictions between different sources, suggesting fixes for you to approve. Check it out (Open Source): The app is fully open-source and brings-your-own-key (OpenAI, Anthropic, Google, or any custom endpoint). Since I vibecoded this without prior TS experience, there will definitely be some bugs, but it’s been incredibly stable for my own use cases. GitHub (APK and EXE in the Releases): https://github.com/Kellysmoky123/LlmWiki If you find any issues or want to help refine the agents, please open an issue or a PR. I'd love to see where we can take this "compiled knowledge" idea! submitted by /u/kellysmoky [link] [comments]

LLM Documentation accuracy solved for free with Buonaiuto-Doc4LLM, the MCP server that gives your AI assistant real, up-to-date docs instead of hallucinated APIs

LLMs often generate incorrect API calls because their knowledge is outdated. The result is code that looks convincing but relies on deprecated functions or ignores recent breaking changes. Buonaiuto Doc4LLM addresses this by providing free AI tools with accurate, version-aware documentation—directly from official sources. It fetches and stores documentation locally (React, Next.js, FastAPI, Pydantic, Stripe, Supabase, TypeScript, and more), making it available offline after the initial sync. Through the Model Context Protocol, it delivers only the relevant sections, enforces token limits, and validates library versions to prevent mismatches. The system also tracks documentation updates and surfaces only what has changed, keeping outputs aligned with the current state of each project. A built-in feedback loop measures which sources are genuinely useful, enabling continuous improvement. Search is based on BM25 with TF-IDF scoring, with optional semantic retrieval via Qdrant and local embedding models such as sentence-transformers or Ollama. A lightweight FastAPI + HTMX dashboard provides access to indexed documentation, queries, and feedback insights. Compatible with Claude Code, Cursor, Zed, Cline, Continue, OpenAI Codex, and other MCP-enabled tools. https://github.com/mbuon/Buonaiuto-Doc4LLM submitted by /u/mbuon [link] [comments]

Google engineer rejected by 16 colleges uses AI to sue universities for racial discrimination

submitted by /u/Fcking_Chuck [link] [comments]

How does the ML community view AI-assisted writing in technical discussions? [D]

I've noticed an interesting contrast between professional and casual technical discussions. In the corporate engineering environment where I work, AI-assisted writing is increasingly encouraged. When I produce structured technical explanations — often polished with LLMs — the feedback is positive, especially for documentation or implementation guidelines. Clarity helps decision-making and makes collaboration across teams easier. However, in more informal communities (including Reddit), I've noticed a different reaction. Well-structured questions and arguments are sometimes dismissed as "AI slop," or met with comments like: "If you’re not interested in writing it, I’m not interested in reading it. Come back without using AI." That contrast surprised me. The same level of structure and clarity that’s valued in professional environments can trigger suspicion in casual technical discussions. I'm curious how others in the ML community think about this: Do you view AI-assisted writing negatively in technical discussions? Where do you draw the line between "assistance" and "outsourcing thinking"? Does AI-polished writing change how you evaluate technical credibility? submitted by /u/Boris_Ljevar [link] [comments]

Maestro v1.6.1 — multi-agent orchestration now runs on Claude Code, Gemini CLI, AND OpenAI Codex !

Maestro is an open-source multi-agent orchestration platform that coordinates 22 specialized AI subagents through structured workflows — design dialogue, implementation planning, parallel subagents, and quality gates. It started as a Gemini CLI extension. v1.5 added Claude Code. v1.6.1 adds OpenAI Codex as a third native runtime — and rebuilds the architecture so all three share a single canonical source tree. Install: # Gemini CLI gemini extensions install https://github.com/josstei/maestro-orchestrate # Claude Code claude plugin marketplace add josstei/maestro-orchestrate claude plugin install maestro@maestro-orchestrator --scope user # OpenAI Codex git clone https://github.com/josstei/maestro-orchestrate cd maestro-orchestrate # Open Codex, run /plugins, select Maestro, hit install What's new in v1.6.1: OpenAI Codex support. Full third runtime — all 22 agents, 19 skills, MCP entry-point, runtime guide. Drop-in like the other two. Canonical source architecture. One src/ tree serves all three runtimes via dynamic resolution. No more forks, no more drift. Add a feature once, it ships everywhere. MCP servers decomposed. Two ~38,000-line bundled MCP server files replaced by ~14-line entry-points backed by a modular handler tree. Easier to read, extend, and test. New MCP tools. get_agent returns agent methodology by name. get_runtime_context returns platform-specific config (delegation patterns, tool mappings, env vars). Entry-point generation. Adding a new command no longer means hand-editing three nearly-identical files. Templates generate them. What Maestro does (if you haven't seen it before): You describe what you want to build. Maestro classifies complexity, asks structured design questions, proposes architectural approaches with trade-offs, generates an implementation plan with dependency graphs, then delegates to specialized agents — coder, tester, architect, security engineer, data engineer, etc. — with parallel subagent implementation for independent phases. Simple tasks get an Express workflow (1-2 questions, brief, single agent, code review, done). Complex tasks get the full Standard workflow with a design document, implementation plan, and quality gates that block on Critical/Major findings. 22 agents across 8 domains. Least-privilege tool access enforced per agent. Same orchestration. Whichever AI coding platform you use. Links: GitHub: https://github.com/josstei/maestro-orchestrate Release: https://github.com/josstei/maestro-orchestrate/releases/tag/v1.6.1 Thanks to everyone who's used and starred Maestro — 294 and climbing. The Codex integration I teased in the v1.5 post is here, and the canonical-source rewrite means future features hit all three runtimes at once. If Maestro has helped your workflow, a star goes a long way. 🎼 submitted by /u/josstei [link] [comments]