标签：#Agents

been building AI agent infrastructure for the past few months. The two things that kept biting me — and kept coming up when I talked to other devs building agents — were runaway costs and agents doing irreversible things without asking first. So I built gvnr: an open-source MCP server that gives agents per-agent spend caps (hard-stop before a call if the budget's gone) and a human approval gate (agent asks, you get a mobile link, you approve or deny, agent waits). Both work as plain REST calls or MCP tools — no platform to adopt, no SDK. It's live. You can get an API key in one curl command and try the approval gate for free (it doesn't burn the trial ops). Source is at github.com/mightbesaad/gvnr . Here's what I genuinely want to know from devs building in this space: Does the spend-cap shape match how you think about cost control, or do you manage that somewhere else entirely? Is the approval gate useful if it's email-only and single-approver, or does that make it a toy? What flag would stop you from wiring this into an agent you actually run? Not fishing for encouragement — if this is solving the wrong problem, or solving it the wrong way, I'd rather know now.

The dangerous part of web extraction is not the error. The dangerous part is a clean JSON response that looks correct and is not. If an AI agent uses that output, the mistake does not stay inside a scraper. It moves into a report, a lead list, a price alert, a CRM update, or an automated decision. So before you trust any web extraction API in an agent workflow, test whether it fails honestly. Here is the checklist I use. 1. Test a real page, not a demo page Demo pages are usually polite little museum exhibits. Use pages that behave like the actual internet: a JavaScript-heavy product page a search results page a page with missing fields a login-gated page a blocked or rate-limited page a thin page that has layout but little useful content If the tool only looks good on clean static pages, you have not learned much. 2. Check whether the API separates fetch success from extraction success A page can return HTTP 200 and still be useless. Common examples: the final page is a login screen the visible content is a bot challenge the useful data loads after hydration and never appeared in the fetch the page contains a generic country selector instead of the product the source has navigation text but no actual item data The extractor should not treat these as success just because the request completed. A better response says something like: { "status" : "failed" , "failure_type" : "login_required" , "extracted" : null , "next_step" : "Use a public URL, authorised access, or sample content." } That is boring. Boring is good here. Boring means the agent can stop safely. 3. Ask for fields that are not on the page This is the easiest lie detector. Ask the extractor for something impossible: Extract the product name, price, stock status, warranty length, CEO name, office address, and refund policy. If the page only contains product name and price, the API should say the other fields are missing or low confidence. It should not politely invent them because the schema asked nicely.

TL;DR I built AutoMaintainer , a multi-agent AI system that transforms GitHub issues into production-ready pull requests during the Qwen Cloud AI Hackathon. It coordinates specialized agents (Issue Analyst, Developer, QA, Security, Documentation, Reviewer) to solve problems like a real engineering team—all while keeping humans in control. Here's what I learned. The Problem Open-source maintainers face a brutal reality: 📚 Overwhelming issue backlogs 🔄 Repetitive bug fixes and documentation gaps ⏱️ Code review bottlenecks 😴 Burnout from handling everything solo Existing AI tools help write code, but they don't orchestrate the entire workflow: planning, development, testing, security review, documentation, and human approval. What if we could build an AI engineering team that collaborates like real developers? The Solution: AutoMaintainer AutoMaintainer is a multi-agent orchestration system that mirrors a real software company: Issue Analyst – Reads GitHub issues, extracts requirements, assesses severity Architect – Analyzes repo structure, designs the implementation approach Developer – Writes code, updates files, creates new modules QA Tester – Generates tests, validates fixes, checks edge cases Security Agent – Scans for vulnerabilities, prevents dangerous patterns Documentation – Updates changelogs, PR summaries, release notes Reviewer – Scores code quality, recommends improvements Human Approval Gateway – Final human review before merge The result? A pull request that's analyzed, built, tested, secured, documented, and reviewed—all before a human ever sees it. Tech Stack Frontend Next.js – React framework for the dashboard UI Tailwind CSS – Rapid, utility-first styling TypeScript – Type safety for the frontend layer Backend FastAPI (Python) – Lightweight, async-first API Qwen-compatible LLM API – AI model integration for all agents SQLite + Async (aiosqlite) – Persistent pipeline and memory storage Redis-ready architecture – Prepared for distributed queuing Integr

LinkedIn’s Karthik Ramgopal and Prince Valluri discuss leveraging AI as a new execution model for large-scale engineering. They explain how to move beyond fragmented implementations by building platform abstractions for orchestration, structured context, and safe tooling like MCP. They share architectural insights from real-world coding, observation, and UI testing agents built at LinkedIn. By Karthik Ramgopal, Prince Valluri

It is time to put my proposition made in my previous blog post to the test. Is it possible to spec an application for execution by an agent without encoding it in source? Let's find out. One type of application every knowledge worker is familiar with is task management. Every task has a lifecycle status, dependencies on other tasks, and a history of progress. Let's give agents their own. TaskTrack is a simple but non-trivial task management system variant implemented as a Specify spec. It goes beyond checkbox-based to-do lists that agents sometimes use internally and mimics the key system features listed above. TaskTrack defines two procedures: a "Plan Authoring Run" to create an interconnected set of tasks from requirements and a "Plan Execution Run" to advance a previously authored plan toward completion. One execution run might not always be enough to achieve completion, because TaskTrack allows requesting human feedback and incorporating it during the next execution run. Furthermore, every execution run is divided into "Task Processing Run" sub-procedures to allow for advanced agent context management. TaskTrack implements all of this in less than 300 lines of text. If the implementation used source code, then, depending on the programming language, this would be enough space to implement only the required file I/O operations (TaskTrack uses files for simplicity, not a database). Natural language can easily become quite bloated, but a stringent, scientific writing style and extensive use of what the Specify standard offers can effectively counter that. The official test is, how could it be any other way, the implementation of yet another uninspired Breakout clone. The requirements, the completed TaskTrack plan, and the deliverable are contained in the repository. If you want to run the test yourself, the included README file contains the necessary information, including the launch prompts for both the authoring agent and the execution agent. Please note how both

The Quiet Threshold There's a moment in working with generative models that nobody really talks about, because it doesn't look like progress. It looks like surrender. For the first few months you write prompts. You optimize them. You collect tricks: chain-of-thought, role assignments, few-shot examples, the right magic words. You treat the model like a stubborn intern who needs very precise instructions. And it works — sort of. You get outputs. You ship things. Then one day you notice you've stopped doing any of that. You're just writing. You're typing the way you'd talk to a collaborator at 2am, half-formed sentences, the actual shape of your thinking before it's been edited into something presentable. And the model is answering as if it had been in the room the whole time. This is the quiet threshold. It's not a technical milestone. The model didn't get smarter. You stopped performing. Most people never cross it. They keep prompting at the machine because they're still treating it as an audience to impress, an authority to convince, or an obstacle to outmaneuver. They're managing how they look to a thing that has no opinion of them. And the outputs reflect that — polished, hollow, slightly anxious. The artists I trust on this stuff all describe the same shift: a point where they stopped writing FOR the model and started thinking THROUGH it. The work got rougher and stranger and more theirs. The tool disappeared. What's left is just the practice — the same one you had before, but louder, faster, more honest with itself. I suspect this is the actual measure of fluency with these systems. Not the prompts you can write. The masks you can finally drop.

Lets start our discussion from 2010 . Timeperiod 2010 - 2020 we have predictive AI models such as Recommendation systems , customer segmentation etc .. From 2020 the when the generative models were introduced to the world then the landscape was completely changed . We have this generative era till 2022 . Then industry was stepped into a new era called "Augumentation" models like AI Copilot . This was continued from 2022-2024 . Then came AI Agents—one of the most transformative innovations of the modern AI era. Unlike traditional AI systems that primarily generate responses, agents can reason, plan, use tools, and execute tasks autonomously. Today, the industry is rapidly evolving toward Autonomous Systems, where multiple specialized agents collaborate through orchestration frameworks to solve complex real-world problems. The best AI Timeline : Traditional ML ↓ Deep Learning ↓ Transformers (2017) ↓ Foundation Models ↓ LLMs (GPT Era) ↓ Prompt Engineering ↓ Embeddings ↓ Vector Databases ↓ RAG ↓ Function Calling ↓ AI Agents ↓ Agent Frameworks ↓ Multi-Agent Systems ↓ MCP ↓ Agentic AI ↓ Autonomous AI Organizations Just in the span of 6 years we saw a drastic change in the evolution of AI. Can't imagine how this AI is going to be in the next few years. ai #machinelearning #python

Every AI agent ships with the same bottleneck: it can only reason over what it can reach. MCP servers dissolve that boundary. They expose tools, resources, and prompts to any compliant client over a JSON-RPC wire format so lean you can implement it in an afternoon. Yet most developers grab a framework, copy a template, and ship something they can barely debug. Forge starts differently. You will build an MCP server from the bare protocol up, understand every byte on the wire, and gain the mental model that makes every future server trivial. The Idea (60 Seconds) MCP is a JSON-RPC 2.0 protocol. A client sends a request. Your server returns a response. Three request types power the core loop: initialize , handshake. Client and server exchange capabilities. tools/list , discovery. Server returns every tool it offers, each with a JSON Schema describing its inputs. tools/call , execution. Client names a tool and passes arguments. Server runs the handler and returns structured content. Transport is either stdio (JSON-RPC over stdin/stdout) or HTTP (Streamable HTTP). Stdio is the simplest place to start: read a line from stdin, parse it, dispatch, write a line to stdout. That is the entire architecture. Everything else is error handling, schema validation, and ergonomics. Why This Matters MCP servers are the new APIs. Where REST gave machines endpoints, MCP gives agents tools with typed inputs and structured outputs. Every integration layer from IDE assistants to autonomous workflows converges on this protocol. The standard is young. The primitives are stable. The surface area is small enough to hold in your head all at once. Knowing the wire format gives you three advantages frameworks obscure: Debugging , when a tool call fails, you can read the raw JSON-RPC message and pinpoint the fault in seconds. Portability , any language, any runtime, any transport. Write a server in Bash if you want. The protocol is the contract. Evolution , MCP will add capabilities. Understanding

I Read Your AI Agent Logs So You Don't Have To: A $149 Service That Beats Another Dashboard What if the cheapest fix for your broken AI agent is a stranger reading 40 hours of traces for $149? I spent the last month doing exactly that — reading roughly 40 hours of production logs from teams running LangGraph, CrewAI, and AutoGen agents for paying customers. Not building observability dashboards. Not comparing LangSmith vs Langfuse. Reading the actual traces and writing up what was wrong, what to fix, and in what order. Three observations from those 40 hours: The dashboard was never the problem. Every team already had LangSmith or Helicone or a homegrown equivalent logging every LLM call. None of them were reading the logs. The "fix" was almost always one of seven patterns. I kept seeing the same shapes — stuck retry loops, idempotency gaps, tool-call argument drift, etc. — dressed up in different framework jargon. The teams that asked for "another tool" were the ones least likely to use it. They had 14 tools. The teams that paid for an hour of my time were the ones who said "I don't have time to look at this myself." That second group is who I'm now building a $149 service for. Here's why I think it works, what the deliverable looks like, and where the limits are. Why a $149 fixed-fee reading and not an hourly rate I tested three pricing models against the same deliverable: a written diagnostic of an agent's last 7 days of traces, prioritized fixes with code-level examples, and a 30-minute async follow-up. Model Conversion Avg revenue / inquiry Notes $200/hr (estimated 3hr) 2/40 inquiries $15 (lost 38 to sticker shock) Freelance default, fails on cold traffic $1,500 flat project 0/40 inquiries $0 Above the "I'll just keep it broken" threshold for most small teams $149 fixed diagnostic 11/40 inquiries $41 Below "another contractor" threshold, above "free advice" The $149 number is the inversion point — low enough that a stressed eng lead can expense it without a meet

You have explained your tech stack to your coding agent four times this month. You mentioned your preferred approach to a problem in January, and your agent has no idea it ever happened. You corrected a decision last week and the old version is still surfacing. You set up context at the start of every session because there is nowhere for it to go at the end. This is not a model problem, as GPT-4, Claude, and Gemini all have the same limitations. The model is stateless. They all have inbuilt memory, and still every session starts from zero unless you have the infrastructure to persist what matters and surface it at the right moment. That sophisticated memory infrastructure is what most developers do not have. VEKTOR Slipstream v1.6.3 is a local-first memory SDK for AI agents. This release adds the layer most memory systems skip: not just storing what you tell it, but managing what should still be there months later: curation. What you actually get Before the architecture: What changes for you as a developer embedding this SDK. Every AI memory system forces decisions you didn’t realise you were making. Where does your agent’s context actually lives, is it on your machine or on someone else’s server? Are you paying per token every time your agent understands a memory, or does that happen locally? When you connect your GitHub, your calendar, your files — where does all that data go, and who can see it? Most memory systems answer all four questions for you, quietly, in their terms of service. VEKTOR’s answer to all four is the same: your machine, your data, your rules. Memory lives in a single SQLite file you own. Embeddings run locally on CPU — no API calls, no per-token cost, no data leaving the process. MCP connectors spawn as local stdio processes; nothing is routed through an external service. There is no telemetry, no cloud sync, no account required. If you want to understand exactly what your agent knows about you, you open the database with any SQLite browser and

Anthropic published a thoughtful guide to making skills. It is worth reading, but it's a map of work you should not have to do. The Claude Code team wrote a piece on how they use agent skills . If you make skills, read it. It is honest and tells you something important: making a good skill is real work. Here's what the guide covers. It sorts skills into nine categories. It explains progressive disclosure, where the agent knows which files to load and when. It covers scripts, config files, combining skills together, and writing the description so the model reaches for the skill at the right moment. All of that is true and useful. It is also a lot to learn. And most of it exists only because you are doing the work by hand. We're SkillsCake . We make and score agent skills all day. So we read this guide a little differently than someone meeting skills for the first time. Here's what we think. Skills are infinite The guide splits skills into types: library reference, verification, and so on. That is a helpful way to teach a class. It is not what a skill actually is. A skill is prose that tells an agent how to do one thing, sometimes with scripts attached. The set of possible skills is not nine boxes. It is every job you could describe in writing; it's infinite. Categories are how a person gets a handle on something that open-ended. They are scaffolding for learning, not the shape of the thing. This matters because the moment you think in categories, you start bending your skill to look like the example in its bucket. Your real job rarely fits the bucket. The best engineered skill is the one written for your exact task, by an expert. Doing it yourself might not be worth it Progressive disclosure, scripts, config, descriptions tuned for the model, gotchas earned by failing, and eval loops: none of that is busywork. It's how a good skill gets built by hand. The guide is not overcomplicating anything. It is being honest about what the manual path costs. But that is the poin

It all started in a plaza. One guy with apples, another with wheat. They looked at each other, negotiated, and traded. That's how commerce worked for thousands of years: face to face, hand to hand, trust to trust. If you wanted to buy something, you had to go where it was. If you wanted to sell, you had to wait for someone to show up. Commerce had a physical limit: your body. You couldn't be in two places at the same time. Your market was your street, your town, your city. Nothing more. Then internet came along and someone asked: what if the store doesn't need walls? E-commerce eliminated distance. Amazon started selling books from a garage. MercadoLibre connected a seller in Santiago with a buyer in Antofagasta. Shopify gave an online store to anyone with a credit card. Suddenly, an artisan in southern Chile could sell to the entire country. An entrepreneur in Colombia could have clients in Mexico. The market stopped being a street and became the planet. But e-commerce had a problem nobody wanted to see: it still needed a human behind it. Someone had to update the inventory. Someone had to answer the questions. Someone had to make the quotes, check the payments, control the stock, send the shipments, analyze the metrics, decide the prices. E-commerce digitized the storefront, but it didn't digitize the operation. And that's where we are now. MCP-Commerce is not a term that exists yet. I'm inventing it because I need a name for what's coming. MCP — Model Context Protocol — is a protocol that lets AI use tools. Not "display" tools. Use them. Read a database, send an email, create an invoice, update an inventory, analyze this month's sales. In traditional commerce, you were the store. In e-commerce, you had an online store. In MCP-commerce, the AI IS your operation. It's not a chatbot that answers questions. It's a system that manages your entire business through conversation. You say "how much did I sell this week" and it responds with real data. You say "I need to c

This is part sixteen in a series about managing the growing pile of skills, scripts, and context that AI coding agents depend on. The 0.8.0 release notes cover the storage and pipeline changes that shipped alongside this rewrite; Part thirteen covers how the new profiles.improve config drives the improve pipeline. Config files are where projects go to accumulate technical debt quietly. Each new feature gets a new key. Each new key gets a new parser. Each parser has slightly different error handling, slightly different defaults, and slightly different ideas about what "invalid" means. Nobody notices until a user files an issue that says "I had a typo in my config and akm just silently used defaults for three weeks." That was the state of akm's config layer going into 0.8.0. What the Old Shape Looked Like The v1 config had three top-level blocks that grew independently over two years: llm.* for LLM connection settings, agent.* for agent process settings, and llm.features.* boolean flags gating per-feature LLM calls. The features block was nested under llm for historical reasons even though many features used the agent, not the LLM. The agent's per-process map lived under agent.processes , while LLM-gated features used llm.features.index.metadata_enhance style dotted paths. Each block had its own parser function. parseLlmConfig , parseEmbeddingConfig , parseIndexConfig , and a dozen more. The comment at the top of the new config-schema.ts is blunt about it: the Zod schema "replaces the ~1.4k LOC of legacy per-shape parsers." The problems that accumulated in that ~1.4k LOC: Unknown keys were silently accepted. If you wrote llm.temperaure (typo), the parser ignored it and fell back to the default temperature. No warning. You tuned a key that did nothing. Bad JSON was masked. The config loader caught JSON parse errors and fell back to DEFAULT_CONFIG — the compiled-in defaults. Your entire config file could be corrupt and akm would start without complaint, using defaults a

This is part fifteen in a series about managing the growing pile of skills, scripts, and context that AI coding agents depend on. Part ten introduced the improve pipeline and how it generates proposals. Part twelve covered belief-aware memory, which feeds directly into the confidence scores covered here. The fundamental problem with agent-generated stash updates is trust. You want to capture what the agent learned — the debugging insight from last Tuesday's session, the architectural pattern it derived from reviewing twenty PRs — without blindly writing unreviewed content into the knowledge base your other agents depend on. One bad promotion and you've contaminated search results with a hallucinated fact that will keep showing up until someone notices. akm's proposal queue is the answer to that problem. Introduced in 0.7.0 and extended in 0.8.0, it separates generation from promotion. Every agent-driven change writes to a durable queue first. Nothing reaches your live stash until you explicitly accept it. The queue is the safety net. How the Queue Works When akm improve or akm propose runs, the output goes to the proposal queue — not to your stash. Proposals live outside the asset tree. They never appear in akm search results and never get indexed alongside your real assets. The quality: "proposed" marker ensures this at the database level: proposed assets are excluded from default search and only surface through the akm proposal * commands or an explicit --include-proposed flag. This means an agent can generate dozens of proposals in a single akm improve run and none of them affect your live stash until you decide they should. Multiple proposals for the same ref coexist without filesystem collisions. You can review them at your own pace, reject the bad ones, and accept the rest in whatever order makes sense. The complete review workflow: akm proposal list # see what's pending akm proposal show < id > # render the full proposal content akm proposal diff < id > # dif

This post is part of the akm-knowledge series. Part ten introduced the improve pipeline — what each phase does and how to schedule it. This post goes deeper on what continuous operation looks like in practice: the hardware numbers, the reliability bugs we hit at 48 runs per day, and the observability layer we built to keep watch. Most people think of AI agent memory as something that happens during a session. You talk to your agent, it learns things, maybe you save a few notes, the session ends. The next session starts cold. akm improve is built around a different model: a continuous background process that runs on your own hardware, against local models, and quietly curates your agent's knowledge base while you work on other things. No cloud API required. No per-token billing for the maintenance pass. A GPU you already own, a model you already have downloaded, running on a schedule. This post covers what 24 hours of autonomous operation actually looks like, how consumer-grade GPUs handle the load, the reliability work that makes continuous operation viable, and the observability layer that lets you know it's working without watching logs. What akm improve Does in 24 Hours akm improve is a multi-phase pipeline. The core pass — consolidation — loads your memory pool, groups related memories into chunks, sends each chunk to a local LLM for a consolidation plan (merge similar memories, promote high-signal ones to your stash, delete redundant ones, surface contradictions), and then executes those plans. After consolidation, memory inference runs a lightweight factual extraction pass, and graph extraction updates the entity-relation index. The pipeline is scheduled to run automatically. Here is what one 24-hour window produced: Metric Value Runs completed 48 / 48 — zero failures Memories processed 14,189 Promoted to stash 1,361 Merged (deduplication) 49 (64 secondaries absorbed) Contradictions surfaced 211 Deleted (redundant) 31 Memory inference yield 69.3% — 115 new ato

This is part thirteen in a series about managing the growing pile of skills, scripts, and context that AI coding agents depend on. Part ten covered the full improve pipeline — all five phases and how they connect. Part fourteen covers what 48 runs per day looks like in practice, including hardware benchmarks and the reliability bugs that surface at that frequency. The reflect pass inside akm improve has three execution modes. Most installs are still running the slowest one. Agent mode — the original — spawns an opencode or claude subprocess for each reflect call. The subprocess starts cold, acquires a session, assembles context, makes its LLM call, and exits. That cold-start overhead is real: each call takes approximately 30 seconds on a quiet machine. Run akm improve against a 69-ref stash and the reflect phase alone costs about 35 minutes. SDK mode eliminated the subprocess. The reflect call runs in-process, cutting per-call latency to 10–15 seconds. A 69-ref run drops to 12–17 minutes — better, but still bounded by round-trip overhead that the reflect task does not actually need. LLM mode removes the round trip entirely. The context for reflect is statically pre-assembled — no live tool calls, no file reads, no external context needed. A direct HTTP call to the LLM endpoint is sufficient, and it costs 6–10 seconds per call. A 69-ref run completes in 8–10 minutes. Mode Per-call latency 69-ref run agent (CLI subprocess) ~30s ~35 min sdk (in-process) ~10–15s ~12–17 min llm (direct HTTP) ~6–10s ~8–10 min The 3–4× end-to-end improvement is from eliminating overhead that was never necessary for what reflect does. Why Reflect Does Not Need an Agent The reflect pass takes a stash asset, examines its current content, and proposes a refined version. The inputs are fixed before the pass starts: the asset text, its metadata, and the improvement prompt. Nothing changes mid-call. No files need to be opened. No search queries need to fire. No external context needs to be pulled

A self-improving memory loop sounds like a clear win until you watch it rewrite something correct with something outdated. The agent remembered a fact. You verified it. A later consolidation pass ran against a stale context window, decided the memory was imprecise, and replaced it with a weaker version. The original was better. You lost ground. This is the failure mode that belief-aware memory was built to prevent. Not "agents write wrong things" — that's a model quality problem. The specific failure is: the improve loop, running unsupervised, overwrites correct content it should have left alone. A loop that can degrade its own best work is worse than no loop at all. akm 0.8.0 ships captureMode and beliefState as first-class frontmatter fields on memory assets. Together they tell the consolidation pass what each memory is, what the agent believes about it, and whether it is eligible to be rewritten. The Two Capture Modes Every memory asset now carries a captureMode field. It has two values. hot means the memory was written or explicitly confirmed by a human. The improve loop treats hot memories as read-only. No consolidation plan, no merge proposal, no rewrite. If every memory in a chunk is captureMode: hot , the consolidation pass skips the LLM call for that chunk entirely — the chunk is counted as judgedNoAction before a single token is spent. This is the all-hot chunk early-exit. background means the memory was generated by an agent — promoted during a prior consolidation run, written by an inference pass, produced by akm remember without explicit human review. Background memories are eligible for improvement. The consolidation pass can propose merges, rewrites, deletions, or upgrades. When no captureMode is set, the memory is treated as eligible for consolidation. Memories that existed before 0.8.0 are treated this way on first encounter. --- captureMode : hot beliefState : asserted description : Primary LM Studio endpoint moved to Shredder (192.168.0.99:1234) -

This is part eleven in a series about managing the growing pile of skills, scripts, and context that AI coding agents depend on. Part nine covered workflow assets and resumable procedures. Part ten introduced the improve pipeline that continuously curates your stash. Earlier parts addressed teams, distributed stashes, and community knowledge. Most automation with AI agents is reactive. You open a session, give the agent a task, wait for the result, close the session. The agent's clock runs when you run it. Task assets flip that model. A task is a YAML file in your stash that defines a workflow — what to run, when to run it, what environment it needs, and how long it's allowed to take. Once registered, the task runs on schedule without your involvement. The OS scheduler calls akm tasks run <id> , which executes the task and writes the result to state.db . You find out what happened when you check akm health or look at the log. This is the piece of akm 0.8.0 that makes continuous operation possible. The improve loop runs twice an hour because a task asset says it does. The hourly Discord health report fires because a task asset says it does. Neither requires an open terminal. The Task Asset Format Task assets live at <stash>/tasks/<id>.yml . The filename is the task ID. A minimal task looks like this: schedule : 0 * * * * command : akm improve --auto-accept 90 enabled : true That's enough to install a cron entry and run akm improve at the top of every hour. The full schema adds metadata and per-task timeout control: schedule : " 7,37 * * * *" command : akm improve --auto-accept 90 --timeout-ms 1620000 enabled : true timeoutMs : 1800000 name : akm-improve description : Run the improve pass at :07 and :37 — reflect, distill, consolidate, lint, and eval. when_to_use : Twice per hour; leaves ~23 minutes of idle headroom between completions. tags : - improve - maintenance The fields that matter most: Field Required Purpose schedule yes Standard cron expression. Maps to cro

This is part ten in a series about managing the growing pile of skills, scripts, and context that AI coding agents depend on. Part nine covered workflow assets, vault assets, and the writable git stash. Part eight tackled multi-wiki support for structured research. Earlier parts addressed teams, distributed stashes, feedback scoring, and community knowledge. This one is about entropy. You ship a feature. Your agent writes several memories during the session — partial findings, a workaround, a note about the build step that kept failing. Those memories are accurate when written. Three sprints later, the workaround is no longer needed, two of the memories say slightly different things about the same subsystem, and the note about the build step refers to a CI config that was replaced. None of this is catastrophic. But it accumulates. After six months, a significant fraction of your stash is stale, redundant, or quietly wrong. You could audit it manually. In practice, you won't — the stash is too large, the relevance of any given memory is hard to assess without the context where it was created, and the judgment calls (merge these two? promote this? delete that?) are exactly the kind of work that's tedious for a human and tractable for an LLM. akm improve is the answer to that problem. It is a multi-phase pipeline that reads your stash, evaluates asset quality, consolidates scattered memories, extracts structured facts, and maps entity relationships — on a schedule, without manual intervention, producing proposals you can review before anything changes. The Five Phases akm improve is not a single LLM call. It is a sequenced pipeline where each phase produces inputs for the next. Reflect evaluates asset quality. For each asset in scope, the reflect pass reviews the content against usage signals — search hits, retrieval counts, feedback — and produces a quality assessment. Low-quality assets are flagged as candidates for improvement. Since 0.8.0, reflect can run as a dire

Mutagen 0.4.0 addresses the friction points that plague agentic workflows: context bloat, brittle persona transitions, and the lack of a deterministic path from design document to deployed artifact. We aren't trying to make prompts smarter; we are making the harness that executes them more precise. This release introduces a Rust-based service extraction layer that decouples static dependency mapping from generative reasoning, implements an adversarial verification pipeline to gate deployment, and enforces strict stage transitions to prevent the agent personas we rely on from drifting into one another's scopes. The Service Extraction Layer: Decoupling Logic from LLM Context The primary bottleneck in current agentic stacks is token consumption. When a model attempts to reason about a codebase that spans multiple dependencies, it often spends its context window parsing file headers and resolving imports before it can actually write logic. This approach treats static infrastructure as if it were part of the reasoning problem. Mutagen 0.4.0 changes this by introducing a dedicated Rust layer designed to extract service definitions directly from your codebase without polluting the primary agent context. Instead of asking an LLM to map dependencies, the harness queries the local file system and executes static analysis routines. It isolates business logic execution from the generative reasoning loop used by Claude and Codex. This separation allows the model to focus on how to solve a problem rather than where the pieces are located. In practice, this means offloading static infrastructure queries to the harness rather than the LLM. The result is reduced latency and significantly lower token costs for complex applications. You get a dependency map that is as reliable as a compiler's parse tree, not a probabilistic guess from a prompt. // Example: Service extraction logic isolated from the reasoning loop fn extract_services_from_codebase () -> HashMap < String , Vec < Depende