Descript

Descript AI

Descript AI

Descript AI

Descript AI

Descript AI

Descript AI

Descript AI

Descript AI

Descript AI

Descript AI

Show HN: Threadprocs – executables sharing one address space (0-copy pointers)

This project launches multiple independent programs into a single shared virtual address space, while still behaving like separate processes (independent binaries, globals, and lifetimes). When threadprocs share their address space, pointers are valid across them with no code changes for well-behaved Linux binaries.<p>Unlike threads, each threadproc is a standalone and semi-isolated process. Unlike dlopen-based plugin systems, threadprocs run traditional executables with a `main()` function. Unlike POSIX processes, pointers remain valid across threadprocs because they share the same address space.<p>This means that idiomatic pointer-based data structures like `std::string` or `std::unordered_map` can be passed between threadprocs and accessed directly (with the usual data race considerations).<p>This accomplishes a programming model somewhere between pthreads and multi-process shared memory IPC.<p>The implementation relies on directing ASLR and virtual address layout at load time and implementing a user-space analogue of `exec()`, as well as careful manipulation of threadproc file descriptors, signals, etc. It is implemented entirely in unprivileged user space code: &lt;<a href="https:&#x2F;&#x2F;github.com&#x2F;jer-irl&#x2F;threadprocs&#x2F;blob&#x2F;main&#x2F;docs&#x2F;02-implementation.md" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;jer-irl&#x2F;threadprocs&#x2F;blob&#x2F;main&#x2F;docs&#x2F;02-imp...</a>&gt;.<p>There is a simple demo demonstrating “cross-threadproc” memory dereferencing at &lt;<a href="https:&#x2F;&#x2F;github.com&#x2F;jer-irl&#x2F;threadprocs&#x2F;tree&#x2F;main?tab=readme-ov-file#demo" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;jer-irl&#x2F;threadprocs&#x2F;tree&#x2F;main?tab=readme-...</a>&gt;, including a high-level diagram.<p>This is relevant to systems of multiple processes with shared memory (often ring buffers or flat tables). These designs often require serialization or copying, and tend away from idiomatic C++ or Rust data structures. Pointer-based data structures cannot be passed directly.<p>There are significant limitations and edge cases, and it’s not clear this is a practical model, but the project explores a way to relax traditional process memory boundaries while still structuring a system as independently launched components.

Spending too much time on content creation? Writesonic accelerates your workflow with AI. Biosynth scaled scientific product descriptions from 250 to 5,000 per week using Writesonic. 🌿 Discover the w

Spending too much time on content creation? Writesonic accelerates your workflow with AI. Biosynth scaled scientific product descriptions from 250 to 5,000 per week using Writesonic. 🌿 Discover the wisdom of your body. Free diagnosis from the profile link. #AItools #ContentCreation

[Resource]: WRITE THE NAME OF YOUR RESOURCE HERE

### Display Name AI.MD ### Category Agent Skills ### Sub-Category General ### Primary Link https://github.com/sstklen/ai-md ### Author Name sstklen ### Author Link https://github.com/sstklen ### License MIT ### Other License _No response_ ### Description Converts human-written CLAUDE.md files into AI-native structured-label format using a 6-phase methodology (understand, decompose, label,structure, resolve, test). Battle-tested with 4 LLM models — structured format raised Codex (GPT-5.3) compliance from 6/8 to 8/8 on identical rule content, while reducing file size by 53% and line count by 37% (224 → 142 lines, within Claude Code's recommended 200-line limit). ### Validate Claims Install the skill and run it on any CLAUDE.md over 100 lines. The skill measures before/after byte count and line count, converts to structured-label format with automatic backup (.bak), and reports the diff. Real test data is in the README (4-model comparison table). The examples/ directory contains a complete before/after pair for manual inspection. ### Specific Task(s) Have Claude Code convert an existing CLAUDE.md using the AI.MD skill. Then compare compliance by testing both versions (original backup vs converted) with the same set of questions. The skill's SKILL.md documents the exact 8-question test protocol used in validation. ### Specific Prompt(s) Say: "distill my CLAUDE.md" or "AI.MD" — the skill previews current token cost, shows before/after examples, then offers to convert with full backup. After conversion, say "test my CLAUDE.md" to run the built-in multi-model validation. ### Additional Comments The core insight: LLMs re-read CLAUDE.md every conversation turn. Human prose wastes tokens and splits attention across rules sharing a line. Structured-label format (one concept per line, explicit trigger/action/exception labels, XML section boundaries) gives each rule full attention weight. This is not compression — it's restructuring the same rules into a format LLMs parse more reliably. Full methodology: 6 conversion phases + 5 special techniques documented in SKILL.md (525 lines). ### Recommendation Checklist - [x] I have checked that this resource hasn't already been submitted - [x] It has been over one week since the first public commit to the repo I am recommending - [x] All provided links are working and publicly accessible - [x] I do NOT have any other open issues in this repository - [x] I am primarily composed of human-y stuff and not electrical circuits

[AI Agent] Master Tracking: Complete AI Agent Implementation

## 🎯 Goal Track the complete implementation of autonomous Python AI Agent for CoffeeOrderSystem. --- ## 📋 Implementation Steps ### Phase 1: Infrastructure (Week 1) - [ ] **Step 1:** Setup Python AI Agent Service infrastructure #133 - Python service with FastAPI - Docker integration - Basic health checks - Makefile commands ### Phase 2: AI Integration (Week 1-2) - [ ] **Step 2:** Implement Cognee integration with semantic code search #134 - CogneeService with RAG search - Architecture context gathering - Entity file discovery - Integration tests - [ ] **Step 3:** Implement PlannerAgent with LangChain #135 - TaskPlan models - LangChain planning chain - Prompt templates - Plan generation and posting ### Phase 3: Code Generation (Week 2-3) - [ ] **Step 4:** Implement DevAgent for code generation #136 - GitHub file operations - Code generation prompts - Create/modify/delete operations - Branch management - [ ] **Step 5:** Implement PRAgent and workflow orchestration #137 - PR creation with rich descriptions - Workflow orchestrator - Background task processing - Complete end-to-end flow ### Phase 4: Advanced Features (Week 3-4) - [ ] **Step 6:** Add learning/memory system - Store successful patterns in Cognee - Learn from PR reviews - Avoid failed patterns - Improve over time - [ ] **Step 7:** Add GitHub webhook listener - Auto-trigger on issue label - Real-time processing - Queue management - Concurrent task handling --- ## 🎯 Success Criteria ### MVP (Minimum Viable Product) - ✅ Agent creates plans for issues - ✅ Agent generates compilable code - ✅ Agent creates PRs with descriptions - ✅ Works for simple tasks (add field, update config) - ✅ Error handling with GitHub notifications ### Production Ready - ☐ Handles complex multi-layer changes - ☐ Learns from successful PRs - ☐ Automatic triggering via webhooks - ☐ Rate limiting and queue management - ☐ Comprehensive test coverage (>80%) - ☐ Monitoring and metrics --- ## 📊 Architecture Overview ``` ┌────────────────────────────────────┐ │ GitHub Issues (labeled: ai-agent) │ └───────────────┬────────────────────┘ │ ↓ (webhook or manual trigger) ┌───────────────┼────────────────────┐ │ WorkflowOrchestrator │ └───────────────┬────────────────────┘ │ ┌────────┼────────┐ │ │ │ ↓ ↓ ↓ PlannerAgent DevAgent PRAgent │ │ │ │ │ │ ┌───┼───┐ │ ┌───┼───┐ │ │ │ │ │ │ │ ↓ ↓ ↓ ↓ ↓ ↓ ↓ Cognee LLM GitHub GitHub (RAG) (GPT-4) (API) ``` ### Component Responsibilities **PlannerAgent:** - Analyzes GitHub issue - Searches codebase via Cognee - Creates structured TaskPlan - Posts plan as issue comment **DevAgent:** - Generates code via LLM - Creates/modifies/deletes files - Commits to feature branch - Preserves code style **PRAgent:** - Creates pull request - Writes comprehensive PR description - Links to original issue - Adds testing checklist **WorkflowOrchestrator:** - Coordinates all agents - Handles errors - Posts progress updates - Manages background execution --- ## 📦 Tech Stack ### Core - **Python 3.11+** - Agent runtime - **FastAPI** - Web framework - **LangChain** - LLM orchestration - **OpenAI GPT-4** - Code generation - **PyGithub** - GitHub API client ### AI/ML - **Cognee** - RAG and semantic search - **OpenAI Embeddings** - Vector search - **LangChain Chains** - Prompt management ### Infrastructure - **Docker** - Containerization - **PostgreSQL** - Shared with .NET API - **uvicorn** - ASGI server --- ## 📝 Usage Example ### 1. Create Issue ```markdown Title: Add loyalty points to Customer Labels: ai-agent, enhancement Description: Add LoyaltyPoints field (int, default 0) to Customer entity. Requirements: - Update Domain/Entities/Customer.cs - Update Application/DTOs/CustomerDto.cs - Create EF Core migration - Add unit tests ``` ### 2. Trigger Agent ```bash make agent-process # Enter issue number: 138 ``` ### 3. Monitor Progress Issue comments show: ``` 🤖 AI Agent Started Phase 1/3: Analyzing task... 🤖 Execution Plan Summary: Add LoyaltyPoints field to Customer entity Steps: 1. MODIFY Domain/Entities/Customer.cs 2. MODIFY Application/DTOs/CustomerDto.cs 3. CREATE Migration file 4. CREATE Test file 🛠️ Phase 2/3: Generating code (4 files)... ✅ Step 1/4: modify Customer.cs ✅ Step 2/4: modify CustomerDto.cs ... 📦 Phase 3/3: Creating pull request... 🤖 Pull Request Created: #139 Branch: ai-agent/issue-138 Ready for review! ``` ### 4. Review PR PR includes: - Closes #138 - Comprehensive description - File changes summary - Testing checklist - Risk assessment ### 5. Merge Agent learns from successful merge for future tasks. --- ## 🧪 Testing Strategy ### Unit Tests - Agent logic (plan parsing, code generation) - Service mocks (GitHub, Cognee) - P

[Feature Request]: Gemini prompt caching

### Feature Description Integrate the [Gemini prompt caching](https://ai.google.dev/gemini-api/docs/caching#cost-efficiency) to save LLM costs. ### Reason Context caching is a paid feature designed to reduce cost. Billing is based on the following factors: 1. Cache token count: The number of input tokens cached, billed at a reduced rate when included in subsequent prompts. 2. Storage duration: The amount of time cached tokens are stored (TTL), billed based on the TTL duration of cached token count. There are no minimum or maximum bounds on the TTL. 3. Other factors: Other charges apply, such as for non-cached input tokens and output tokens. ### Value of Feature By reducing both the cost and latency of processing large datasets, this integration transforms the "Context-Augmented" experience that LlamaIndex is known for.

Refactor a-help skill to use RAG-backed retrieval instead of monolithic prompt

## Context The `/a-help` built-in skill is a 48KB monolithic prompt (`src/anteroom/cli/default_skills/a-help.yaml`) that embeds the entire Anteroom reference — config tables, tool descriptions, CLI commands, environment variables, and more. It's at 95% of the 50KB skill prompt limit and growing with every feature. This is unsustainable. Every new config field, tool, or CLI command requires squeezing more into an already-bloated prompt that gets injected in full on every `/a-help` invocation. Additionally, users shouldn't need to remember to type `/a-help` — when someone asks "how do I configure tools?" in a normal conversation, the AI should automatically recognize this as an Anteroom question and invoke the help skill. ## Proposal Two changes: 1. **Slim `a-help`** from a monolithic 48KB inline reference to a ~10-15KB strategy prompt with a curated docs index and explicit `read_file` fallback. The AI reads the specific docs page it needs on demand instead of receiving everything upfront. 2. **Improve auto-invocation reliability** by broadening the `a-help` skill description so the LLM recognizes natural Anteroom questions as matching the skill. This is skill-specific prompt engineering — no changes to shared infrastructure (`invoke_skill` tool, `<available_skills>` catalog instruction, or system prompt builders). This is **not** a RAG integration. The skill stays a pure prompt template — no new fields, no retrieval pipeline changes. ### Benefits - Removes the 50KB ceiling — docs can grow freely - Reduces token cost per `/a-help` invocation (~10K tokens instead of ~12K) - Docs pages stay the single source of truth — no more maintaining parallel content in `a-help.yaml` and `docs/` - New features auto-appear in `/a-help` when their docs pages are written and indexed - Users get help without needing to know about `/a-help` — natural questions trigger it automatically - Zero infrastructure change — works today with no code modifications ### Future: Skill-Scoped RAG Retrieval A separate future issue will explore proper RAG-backed skills with: - Retrieval scoping by source IDs / corpus - Non-user-visible storage for built-in docs - Update semantics for bundled docs - `rag_enabled` skill field and CLI/web parity That's new RAG infrastructure, not a refactor of `a-help`. ## Acceptance Criteria ### Slim a-help (Phase 1 — done in PR #850) - [x] `a-help.yaml` is under 15KB (hard budget — leaves room for growth) - [x] Strategy section tells the AI to check inline quick-ref first, then `read_file` specific docs pages - [x] Curated docs index maps question categories to specific file paths - [x] Inline quick-reference retained for the most common questions (~80% coverage): config layers, tool tiers, approval modes, skill format, CLI commands - [x] Less common reference (full config field tables, env var lists, detailed architecture) moved to docs-only — accessed via `read_file` - [x] Links to #843 content (`docs/cli/porting-from-claude-code.md`, `docs/cli/skill-examples.md`) included in the docs index - [x] Existing skill-loader tests pass — `a-help` still loads as a valid skill ### Auto-invocation (Phase 2) - [ ] `a-help` skill description broadened to trigger auto-invocation for Anteroom questions (description-only change, no shared code) - [ ] Natural questions like "how do I configure tools?" trigger `invoke_skill(name="a-help")` without explicit `/a-help` - [ ] Manual verification: ask Anteroom questions without `/a-help` prefix — AI uses the skill automatically - [ ] If description-only approach proves insufficient, open a separate issue for changing the generic `<available_skills>` instruction in `repl.py:1431-1437` and `chat.py:495-501` with broader eval coverage ## Related Issues - #843 — porting docs and skill examples; `a-help` will link to these new pages - Future: skill-scoped RAG retrieval (not yet filed) - Future (if needed): tune generic `<available_skills>` matching language in `repl.py` and `chat.py` ## Parity **Parity exception**: Built-in skill content change only (YAML `description` field). Both interfaces read the same `a-help.yaml` via the shared skill registry. The `<available_skills>` catalog in both `repl.py` and `chat.py` renders the description identically. No changes to shared prompt builders or runtime behavior. --- ## Implementation Plan ### Summary Slim the `a-help` built-in skill from 48KB to under 15KB by replacing inline reference tables with a curated docs index and `read_file` fallback strategy. Then broaden the skill's `description` field to improve auto-invocation for natural Anteroom questions. ### Phase 1: Slim a-help (done — PR #850) | File | Change | |------|--------| | `src/anteroom/cli/default_skills/a-help.yaml` | Restructure: keep strategy + high-frequency quick-ref + curated docs index; remove low-frequency inline tables | | `tests/unit/test_skills.py` | Size budget assertion (< 15KB) | ### Phase 2: Auto-invocation (skill-specific, no shared code c

Cutting LLM token usage by 80% using recursive document analysis

When you employ AI agents, there’s a significant volume problem for document study. Reading one file of 1000 lines consumes about 10,000 tokens. Token consumption incurs costs and time penalties. Codebases with dozens or hundreds of files, a common case for real world projects, can easily exceed 100,000 tokens in size when the whole thing must be considered. The agent must read and comprehend, and be able to determine the interrelationships among these files. And, particularly, when the task requires multiple passes over the same documents, perhaps one pass to divine the structure and one to mine the details, costs multiply rapidly. **Matryoshka** is a tool for document analysis that achieves over 80% token savings while enabling interactive and exploratory analysis. The key insight of the tool is to save tokens by caching past analysis results, and reusing them, so you do not have to process the same document lines again. These ideas come from recent research, and retrieval-augmented generation, with a focus on efficiency. We'll see how Matryoshka unifies these ideas into one system that maintains a persistent analytical state. Finally, we'll take a look at some real-world results analyzing the [anki-connect](https://git.sr.ht/~foosoft/anki-connect) codebase. --- ## The Problem: Context Rot and Token Costs A common task is to analyze a codebase to answers a question such as “What is the API surface of this project?” Such work includes identifying and cataloguing all the entry points exposed by the codebase. **Traditional approach:** 1. Read all source files into context (~95,000 tokens for a medium project) 2. The LLM analyzes the entire codebase’s structure and component relationships 3. For follow-up questions, the full context is round-tripped every turn This creates two problems: ### Token Costs Compound Every time, the entire context has to go to the API. In a 10-turn conversation about a codebase of 7,000 lines, almost a million tokens might be processed by the system. Most of those tokens are the same document contents being dutifully resent, over and over. The same core code is sent with every new question. This redundant transaction is a massive waste. It forces the model to process the same blocks of text repeatedly, rather than concentrating its capabilities on what’s actually novel. ### Context Rot Degrades Quality As described in the [Recursive Language Models](https://arxiv.org/abs/2505.11409) paper, even the most capable models exhibit a phenomenon called context degradation, in which their performance declines with increasing input length. This deterioration is task-dependent. It’s connected to task complexity. In information-dense contexts, where the correct output requires the synthesis of facts presented in widely dispersed locations in the prompt, this degradation may take an especially precipitous form. Such a steep decline can occur even for relatively modest context lengths, and is understood to reflect a failure of the model to maintain the threads of connection between large numbers of informational fragments long before it reaches its maximum token capacity. The authors argue that we should not be inserting prompts into the models, since this clutters their memory and compromises their performance. Instead, documents should be considered as **external environments** with which the LLM can interact by querying, navigating through structured sections, and retrieving specific information on an as-needed basis. This approach treats the document as a separate knowledge base, an arrangement that frees up the model from having to know everything. --- ## Prior Work: Two Key Insights Matryoshka builds on two research directions: ### Recursive Language Models (RLM) The RLM paper introduces a new methodology that treats documents as external state to which step-by-step queries can be issued, without the necessity of loading them entirely. Symbolic operations, search, filter, aggregate, are actively issued against this state, and only the specific, relevant results are returned, maintaining a small context window while permitting analysis of arbitrarily large documents. Key point is that the documents stay outside the model, and only the search results enter the context. This separation of concerns ensures that the model never sees complete files, instead, a search is initiated to retrieve the information. ### Barliman: Synthesis from Examples [Barliman](https://github.com/webyrd/Barliman), a tool developed by William Byrd and Greg Rosenblatt, shows that it is possible to use program synthesis without asking for precise code specifications. Instead, input/output examples are used, and a solver engine is used as a relational programming system in the spirit of [miniKanren](http://minikanren.org/). Barliman uses such a system to synthesize functions that satisfy the constraints specified. The system interprets the examples as if they were relational rules, and the synthesis e

OpenAI’s Game-Changing o1 Description: Big news in the AI world! OpenAI is shaking things up with the launch of ChatGPT Pro, priced at $200/month, and it’s not just a premium subscription—it’s a glim

OpenAI’s Game-Changing o1 Description: Big news in the AI world! OpenAI is shaking things up with the launch of ChatGPT Pro, priced at $200/month, and it’s not just a premium subscription—it’s a glimpse into the future of AI. Let me break it down: First, the Pro plan offers unlimited access to cutting-edge models like o1, o1-mini, and GPT-4o. These aren’t your typical language models. The o1 series is built for reasoning tasks—think solving complex problems, debugging, or even planning multi-step workflows. What makes it special? It uses “chain of thought” reasoning, mimicking how humans think through difficult problems step by step. Imagine asking it to optimize your code, develop a business strategy, or ace a technical interview—it can handle it all with unmatched precision. Then there’s o1 Pro Mode, exclusive to Pro subscribers. This mode uses extra computational power to tackle the hardest questions, ensuring top-tier responses for tasks that demand deep thinking. It’s ideal for engineers, analysts, and anyone working on complex, high-stakes projects. And let’s not forget the advanced voice capabilities included in Pro. OpenAI is taking conversational AI to the next level with dynamic, natural-sounding voice interactions. Whether you’re building voice-driven applications or just want the best voice-to-AI experience, this feature is a game-changer. But why $200? OpenAI’s growth has been astronomical—300M WAUs, with 6% converting to Plus. That’s $4.3B ARR just from subscriptions. Still, their training costs are jaw-dropping, and the company has no choice but to stay on the cutting edge. From a game theory perspective, they’re all-in. They can’t stop building bigger, better models without falling behind competitors like Anthropic, Google, or Meta. Pro is their way of funding this relentless innovation while delivering premium value. The timing couldn’t be more exciting—OpenAI is teasing a 12 Days of Christmas event, hinting at more announcements and surprises. If this is just the start, imagine what’s coming next! Could we see new tools, expanded APIs, or even more powerful models? The possibilities are endless, and I’m here for it. If you’re a small business or developer, this $200 investment might sound steep, but think about what it could unlock: automating workflows, solving problems faster, and even exploring entirely new projects. The ROI could be massive, especially if you’re testing it for just a few months. So, what do you think? Is $200/month a step too far, or is this the future of AI worth investing in? And what do you think OpenAI has in store for the 12 Days of Christmas? Drop your thoughts in the comments! #product #productmanager #productmanagement #startup #business #openai #llm #ai #microsoft #google #gemini #anthropic #claude #llama #meta #nvidia #career #careeradvice #mentor #mentorship #mentortiktok #mentortok #careertok #job #jobadvice #future #2024 #story #news #dev #coding #code #engineering #engineer #coder #sales #cs #marketing #agent #work #workflow #smart #thinking #strategy #cool #real #jobtips #hack #hacks #tip #tips #tech #techtok #techtiktok #openaidevday #aiupdates #techtrends #voiceAI #developerlife #o1 #o1pro #chatgpt #2025 #christmas #holiday #12days #cursor #replit #pythagora #bolt